1 // Generated Code - DO NOT EDIT !!
2 // generated by 'emugen'
3
4
5 #include <string.h>
6 #include "gles1_opcodes.h"
7
8 #include "gles1_dec.h"
9
10
11 #include "ProtocolUtils.h"
12
13 #include "ChecksumCalculatorThreadInfo.h"
14
15 #include "host-common/logging.h"
16
17 #include <stdio.h>
18
19 namespace gfxstream {
20
21 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.
22
23 #ifdef CHECK_GL_ERRORS
24 # define SET_LASTCALL(name) sprintf(lastCall, #name)
25 #else
26 # define SET_LASTCALL(name)
27 #endif
decode(void * buf,size_t len,IOStream * stream,ChecksumCalculator * checksumCalc)28 size_t gles1_decoder_context_t::decode(void *buf, size_t len, IOStream *stream, ChecksumCalculator* checksumCalc) {
29 if (len < 8) return 0;
30 #ifdef CHECK_GL_ERRORS
31 char lastCall[256] = {0};
32 #endif
33 unsigned char *ptr = (unsigned char *)buf;
34 const unsigned char* const end = (const unsigned char*)buf + len;
35 const size_t checksumSize = checksumCalc->checksumByteSize();
36 const bool useChecksum = checksumSize > 0;
37 while (end - ptr >= 8) {
38 uint32_t opcode = *(uint32_t *)ptr;
39 uint32_t packetLen = *(uint32_t *)(ptr + 4);
40 if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
41 switch(opcode) {
42 case OP_glAlphaFunc: {
43 android::base::beginTrace("glAlphaFunc decode");
44 GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
45 GLclampf var_ref = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
46 if (useChecksum) {
47 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
48 "gles1_decoder_context_t::decode, OP_glAlphaFunc: GL checksumCalculator failure\n");
49 }
50 #ifdef CHECK_GL_ERRORS
51 GLint err = this->glGetError();
52 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFunc\n", err);
53 #endif
54 DECODER_DEBUG_LOG("gles1(%p): glAlphaFunc(func:0x%08x ref:%f )", stream, var_func, var_ref);
55 this->glAlphaFunc(var_func, var_ref);
56 SET_LASTCALL("glAlphaFunc");
57 android::base::endTrace();
58 break;
59 }
60 case OP_glClearColor: {
61 android::base::beginTrace("glClearColor decode");
62 GLclampf var_red = Unpack<GLclampf,uint32_t>(ptr + 8);
63 GLclampf var_green = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
64 GLclampf var_blue = Unpack<GLclampf,uint32_t>(ptr + 8 + 4 + 4);
65 GLclampf var_alpha = Unpack<GLclampf,uint32_t>(ptr + 8 + 4 + 4 + 4);
66 if (useChecksum) {
67 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
68 "gles1_decoder_context_t::decode, OP_glClearColor: GL checksumCalculator failure\n");
69 }
70 #ifdef CHECK_GL_ERRORS
71 GLint err = this->glGetError();
72 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColor\n", err);
73 #endif
74 DECODER_DEBUG_LOG("gles1(%p): glClearColor(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
75 this->glClearColor(var_red, var_green, var_blue, var_alpha);
76 SET_LASTCALL("glClearColor");
77 android::base::endTrace();
78 break;
79 }
80 case OP_glClearDepthf: {
81 android::base::beginTrace("glClearDepthf decode");
82 GLclampf var_depth = Unpack<GLclampf,uint32_t>(ptr + 8);
83 if (useChecksum) {
84 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
85 "gles1_decoder_context_t::decode, OP_glClearDepthf: GL checksumCalculator failure\n");
86 }
87 #ifdef CHECK_GL_ERRORS
88 GLint err = this->glGetError();
89 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthf\n", err);
90 #endif
91 DECODER_DEBUG_LOG("gles1(%p): glClearDepthf(depth:%f )", stream, var_depth);
92 this->glClearDepthf(var_depth);
93 SET_LASTCALL("glClearDepthf");
94 android::base::endTrace();
95 break;
96 }
97 case OP_glClipPlanef: {
98 android::base::beginTrace("glClipPlanef decode");
99 GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
100 uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
101 InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
102 if (useChecksum) {
103 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
104 "gles1_decoder_context_t::decode, OP_glClipPlanef: GL checksumCalculator failure\n");
105 }
106 #ifdef CHECK_GL_ERRORS
107 GLint err = this->glGetError();
108 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanef\n", err);
109 #endif
110 DECODER_DEBUG_LOG("gles1(%p): glClipPlanef(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
111 this->glClipPlanef(var_plane, (const GLfloat*)(inptr_equation.get()));
112 SET_LASTCALL("glClipPlanef");
113 android::base::endTrace();
114 break;
115 }
116 case OP_glColor4f: {
117 android::base::beginTrace("glColor4f decode");
118 GLfloat var_red = Unpack<GLfloat,uint32_t>(ptr + 8);
119 GLfloat var_green = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
120 GLfloat var_blue = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
121 GLfloat var_alpha = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
122 if (useChecksum) {
123 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
124 "gles1_decoder_context_t::decode, OP_glColor4f: GL checksumCalculator failure\n");
125 }
126 #ifdef CHECK_GL_ERRORS
127 GLint err = this->glGetError();
128 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4f\n", err);
129 #endif
130 DECODER_DEBUG_LOG("gles1(%p): glColor4f(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
131 this->glColor4f(var_red, var_green, var_blue, var_alpha);
132 SET_LASTCALL("glColor4f");
133 android::base::endTrace();
134 break;
135 }
136 case OP_glDepthRangef: {
137 android::base::beginTrace("glDepthRangef decode");
138 GLclampf var_zNear = Unpack<GLclampf,uint32_t>(ptr + 8);
139 GLclampf var_zFar = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
140 if (useChecksum) {
141 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
142 "gles1_decoder_context_t::decode, OP_glDepthRangef: GL checksumCalculator failure\n");
143 }
144 #ifdef CHECK_GL_ERRORS
145 GLint err = this->glGetError();
146 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangef\n", err);
147 #endif
148 DECODER_DEBUG_LOG("gles1(%p): glDepthRangef(zNear:%f zFar:%f )", stream, var_zNear, var_zFar);
149 this->glDepthRangef(var_zNear, var_zFar);
150 SET_LASTCALL("glDepthRangef");
151 android::base::endTrace();
152 break;
153 }
154 case OP_glFogf: {
155 android::base::beginTrace("glFogf decode");
156 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
157 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
158 if (useChecksum) {
159 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
160 "gles1_decoder_context_t::decode, OP_glFogf: GL checksumCalculator failure\n");
161 }
162 #ifdef CHECK_GL_ERRORS
163 GLint err = this->glGetError();
164 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogf\n", err);
165 #endif
166 DECODER_DEBUG_LOG("gles1(%p): glFogf(pname:0x%08x param:%f )", stream, var_pname, var_param);
167 this->glFogf(var_pname, var_param);
168 SET_LASTCALL("glFogf");
169 android::base::endTrace();
170 break;
171 }
172 case OP_glFogfv: {
173 android::base::beginTrace("glFogfv decode");
174 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
175 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
176 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
177 if (useChecksum) {
178 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
179 "gles1_decoder_context_t::decode, OP_glFogfv: GL checksumCalculator failure\n");
180 }
181 #ifdef CHECK_GL_ERRORS
182 GLint err = this->glGetError();
183 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogfv\n", err);
184 #endif
185 DECODER_DEBUG_LOG("gles1(%p): glFogfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
186 this->glFogfv(var_pname, (const GLfloat*)(inptr_params.get()));
187 SET_LASTCALL("glFogfv");
188 android::base::endTrace();
189 break;
190 }
191 case OP_glFrustumf: {
192 android::base::beginTrace("glFrustumf decode");
193 GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
194 GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
195 GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
196 GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
197 GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
198 GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
199 if (useChecksum) {
200 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
201 "gles1_decoder_context_t::decode, OP_glFrustumf: GL checksumCalculator failure\n");
202 }
203 #ifdef CHECK_GL_ERRORS
204 GLint err = this->glGetError();
205 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumf\n", err);
206 #endif
207 DECODER_DEBUG_LOG("gles1(%p): glFrustumf(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
208 this->glFrustumf(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
209 SET_LASTCALL("glFrustumf");
210 android::base::endTrace();
211 break;
212 }
213 case OP_glGetClipPlanef: {
214 android::base::beginTrace("glGetClipPlanef decode");
215 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
216 uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
217 if (useChecksum) {
218 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
219 "gles1_decoder_context_t::decode, OP_glGetClipPlanef: GL checksumCalculator failure\n");
220 }
221 size_t totalTmpSize = size_eqn;
222 totalTmpSize += checksumSize;
223 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
224 OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
225 #ifdef CHECK_GL_ERRORS
226 GLint err = this->glGetError();
227 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanef\n", err);
228 #endif
229 DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanef(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_eqn.get()), size_eqn);
230 this->glGetClipPlanef(var_pname, (GLfloat*)(outptr_eqn.get()));
231 outptr_eqn.flush();
232 if (useChecksum) {
233 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
234 }
235 stream->flush();
236 SET_LASTCALL("glGetClipPlanef");
237 android::base::endTrace();
238 break;
239 }
240 case OP_glGetFloatv: {
241 android::base::beginTrace("glGetFloatv decode");
242 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
243 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
244 if (useChecksum) {
245 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
246 "gles1_decoder_context_t::decode, OP_glGetFloatv: GL checksumCalculator failure\n");
247 }
248 size_t totalTmpSize = size_params;
249 totalTmpSize += checksumSize;
250 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
251 OutputBuffer outptr_params(&tmpBuf[0], size_params);
252 #ifdef CHECK_GL_ERRORS
253 GLint err = this->glGetError();
254 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFloatv\n", err);
255 #endif
256 DECODER_DEBUG_LOG("gles1(%p): glGetFloatv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_params.get()), size_params);
257 this->glGetFloatv(var_pname, (GLfloat*)(outptr_params.get()));
258 outptr_params.flush();
259 if (useChecksum) {
260 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
261 }
262 stream->flush();
263 SET_LASTCALL("glGetFloatv");
264 android::base::endTrace();
265 break;
266 }
267 case OP_glGetLightfv: {
268 android::base::beginTrace("glGetLightfv decode");
269 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
270 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
271 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
272 if (useChecksum) {
273 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
274 "gles1_decoder_context_t::decode, OP_glGetLightfv: GL checksumCalculator failure\n");
275 }
276 size_t totalTmpSize = size_params;
277 totalTmpSize += checksumSize;
278 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
279 OutputBuffer outptr_params(&tmpBuf[0], size_params);
280 #ifdef CHECK_GL_ERRORS
281 GLint err = this->glGetError();
282 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightfv\n", err);
283 #endif
284 DECODER_DEBUG_LOG("gles1(%p): glGetLightfv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfloat*)(outptr_params.get()), size_params);
285 this->glGetLightfv(var_light, var_pname, (GLfloat*)(outptr_params.get()));
286 outptr_params.flush();
287 if (useChecksum) {
288 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
289 }
290 stream->flush();
291 SET_LASTCALL("glGetLightfv");
292 android::base::endTrace();
293 break;
294 }
295 case OP_glGetMaterialfv: {
296 android::base::beginTrace("glGetMaterialfv decode");
297 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
298 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
299 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
300 if (useChecksum) {
301 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
302 "gles1_decoder_context_t::decode, OP_glGetMaterialfv: GL checksumCalculator failure\n");
303 }
304 size_t totalTmpSize = size_params;
305 totalTmpSize += checksumSize;
306 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
307 OutputBuffer outptr_params(&tmpBuf[0], size_params);
308 #ifdef CHECK_GL_ERRORS
309 GLint err = this->glGetError();
310 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialfv\n", err);
311 #endif
312 DECODER_DEBUG_LOG("gles1(%p): glGetMaterialfv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfloat*)(outptr_params.get()), size_params);
313 this->glGetMaterialfv(var_face, var_pname, (GLfloat*)(outptr_params.get()));
314 outptr_params.flush();
315 if (useChecksum) {
316 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
317 }
318 stream->flush();
319 SET_LASTCALL("glGetMaterialfv");
320 android::base::endTrace();
321 break;
322 }
323 case OP_glGetTexEnvfv: {
324 android::base::beginTrace("glGetTexEnvfv decode");
325 GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
326 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
327 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
328 if (useChecksum) {
329 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
330 "gles1_decoder_context_t::decode, OP_glGetTexEnvfv: GL checksumCalculator failure\n");
331 }
332 size_t totalTmpSize = size_params;
333 totalTmpSize += checksumSize;
334 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
335 OutputBuffer outptr_params(&tmpBuf[0], size_params);
336 #ifdef CHECK_GL_ERRORS
337 GLint err = this->glGetError();
338 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvfv\n", err);
339 #endif
340 DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvfv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfloat*)(outptr_params.get()), size_params);
341 this->glGetTexEnvfv(var_env, var_pname, (GLfloat*)(outptr_params.get()));
342 outptr_params.flush();
343 if (useChecksum) {
344 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
345 }
346 stream->flush();
347 SET_LASTCALL("glGetTexEnvfv");
348 android::base::endTrace();
349 break;
350 }
351 case OP_glGetTexParameterfv: {
352 android::base::beginTrace("glGetTexParameterfv decode");
353 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
354 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
355 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
356 if (useChecksum) {
357 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
358 "gles1_decoder_context_t::decode, OP_glGetTexParameterfv: GL checksumCalculator failure\n");
359 }
360 size_t totalTmpSize = size_params;
361 totalTmpSize += checksumSize;
362 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
363 OutputBuffer outptr_params(&tmpBuf[0], size_params);
364 #ifdef CHECK_GL_ERRORS
365 GLint err = this->glGetError();
366 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterfv\n", err);
367 #endif
368 DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfloat*)(outptr_params.get()), size_params);
369 this->glGetTexParameterfv(var_target, var_pname, (GLfloat*)(outptr_params.get()));
370 outptr_params.flush();
371 if (useChecksum) {
372 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
373 }
374 stream->flush();
375 SET_LASTCALL("glGetTexParameterfv");
376 android::base::endTrace();
377 break;
378 }
379 case OP_glLightModelf: {
380 android::base::beginTrace("glLightModelf decode");
381 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
382 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
383 if (useChecksum) {
384 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
385 "gles1_decoder_context_t::decode, OP_glLightModelf: GL checksumCalculator failure\n");
386 }
387 #ifdef CHECK_GL_ERRORS
388 GLint err = this->glGetError();
389 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelf\n", err);
390 #endif
391 DECODER_DEBUG_LOG("gles1(%p): glLightModelf(pname:0x%08x param:%f )", stream, var_pname, var_param);
392 this->glLightModelf(var_pname, var_param);
393 SET_LASTCALL("glLightModelf");
394 android::base::endTrace();
395 break;
396 }
397 case OP_glLightModelfv: {
398 android::base::beginTrace("glLightModelfv decode");
399 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
400 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
401 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
402 if (useChecksum) {
403 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
404 "gles1_decoder_context_t::decode, OP_glLightModelfv: GL checksumCalculator failure\n");
405 }
406 #ifdef CHECK_GL_ERRORS
407 GLint err = this->glGetError();
408 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelfv\n", err);
409 #endif
410 DECODER_DEBUG_LOG("gles1(%p): glLightModelfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
411 this->glLightModelfv(var_pname, (const GLfloat*)(inptr_params.get()));
412 SET_LASTCALL("glLightModelfv");
413 android::base::endTrace();
414 break;
415 }
416 case OP_glLightf: {
417 android::base::beginTrace("glLightf decode");
418 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
419 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
420 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
421 if (useChecksum) {
422 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
423 "gles1_decoder_context_t::decode, OP_glLightf: GL checksumCalculator failure\n");
424 }
425 #ifdef CHECK_GL_ERRORS
426 GLint err = this->glGetError();
427 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightf\n", err);
428 #endif
429 DECODER_DEBUG_LOG("gles1(%p): glLightf(light:0x%08x pname:0x%08x param:%f )", stream, var_light, var_pname, var_param);
430 this->glLightf(var_light, var_pname, var_param);
431 SET_LASTCALL("glLightf");
432 android::base::endTrace();
433 break;
434 }
435 case OP_glLightfv: {
436 android::base::beginTrace("glLightfv decode");
437 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
438 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
439 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
440 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
441 if (useChecksum) {
442 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
443 "gles1_decoder_context_t::decode, OP_glLightfv: GL checksumCalculator failure\n");
444 }
445 #ifdef CHECK_GL_ERRORS
446 GLint err = this->glGetError();
447 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightfv\n", err);
448 #endif
449 DECODER_DEBUG_LOG("gles1(%p): glLightfv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
450 this->glLightfv(var_light, var_pname, (const GLfloat*)(inptr_params.get()));
451 SET_LASTCALL("glLightfv");
452 android::base::endTrace();
453 break;
454 }
455 case OP_glLineWidth: {
456 android::base::beginTrace("glLineWidth decode");
457 GLfloat var_width = Unpack<GLfloat,uint32_t>(ptr + 8);
458 if (useChecksum) {
459 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
460 "gles1_decoder_context_t::decode, OP_glLineWidth: GL checksumCalculator failure\n");
461 }
462 #ifdef CHECK_GL_ERRORS
463 GLint err = this->glGetError();
464 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidth\n", err);
465 #endif
466 DECODER_DEBUG_LOG("gles1(%p): glLineWidth(width:%f )", stream, var_width);
467 this->glLineWidth(var_width);
468 SET_LASTCALL("glLineWidth");
469 android::base::endTrace();
470 break;
471 }
472 case OP_glLoadMatrixf: {
473 android::base::beginTrace("glLoadMatrixf decode");
474 uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
475 InputBuffer inptr_m(ptr + 8 + 4, size_m);
476 if (useChecksum) {
477 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
478 "gles1_decoder_context_t::decode, OP_glLoadMatrixf: GL checksumCalculator failure\n");
479 }
480 #ifdef CHECK_GL_ERRORS
481 GLint err = this->glGetError();
482 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixf\n", err);
483 #endif
484 DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixf(m:%p(%u) )", stream, (const GLfloat*)(inptr_m.get()), size_m);
485 this->glLoadMatrixf((const GLfloat*)(inptr_m.get()));
486 SET_LASTCALL("glLoadMatrixf");
487 android::base::endTrace();
488 break;
489 }
490 case OP_glMaterialf: {
491 android::base::beginTrace("glMaterialf decode");
492 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
493 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
494 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
495 if (useChecksum) {
496 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
497 "gles1_decoder_context_t::decode, OP_glMaterialf: GL checksumCalculator failure\n");
498 }
499 #ifdef CHECK_GL_ERRORS
500 GLint err = this->glGetError();
501 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialf\n", err);
502 #endif
503 DECODER_DEBUG_LOG("gles1(%p): glMaterialf(face:0x%08x pname:0x%08x param:%f )", stream, var_face, var_pname, var_param);
504 this->glMaterialf(var_face, var_pname, var_param);
505 SET_LASTCALL("glMaterialf");
506 android::base::endTrace();
507 break;
508 }
509 case OP_glMaterialfv: {
510 android::base::beginTrace("glMaterialfv decode");
511 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
512 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
513 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
514 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
515 if (useChecksum) {
516 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
517 "gles1_decoder_context_t::decode, OP_glMaterialfv: GL checksumCalculator failure\n");
518 }
519 #ifdef CHECK_GL_ERRORS
520 GLint err = this->glGetError();
521 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialfv\n", err);
522 #endif
523 DECODER_DEBUG_LOG("gles1(%p): glMaterialfv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
524 this->glMaterialfv(var_face, var_pname, (const GLfloat*)(inptr_params.get()));
525 SET_LASTCALL("glMaterialfv");
526 android::base::endTrace();
527 break;
528 }
529 case OP_glMultMatrixf: {
530 android::base::beginTrace("glMultMatrixf decode");
531 uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
532 InputBuffer inptr_m(ptr + 8 + 4, size_m);
533 if (useChecksum) {
534 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
535 "gles1_decoder_context_t::decode, OP_glMultMatrixf: GL checksumCalculator failure\n");
536 }
537 #ifdef CHECK_GL_ERRORS
538 GLint err = this->glGetError();
539 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixf\n", err);
540 #endif
541 DECODER_DEBUG_LOG("gles1(%p): glMultMatrixf(m:%p(%u) )", stream, (const GLfloat*)(inptr_m.get()), size_m);
542 this->glMultMatrixf((const GLfloat*)(inptr_m.get()));
543 SET_LASTCALL("glMultMatrixf");
544 android::base::endTrace();
545 break;
546 }
547 case OP_glMultiTexCoord4f: {
548 android::base::beginTrace("glMultiTexCoord4f decode");
549 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
550 GLfloat var_s = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
551 GLfloat var_t = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
552 GLfloat var_r = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
553 GLfloat var_q = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
554 if (useChecksum) {
555 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
556 "gles1_decoder_context_t::decode, OP_glMultiTexCoord4f: GL checksumCalculator failure\n");
557 }
558 #ifdef CHECK_GL_ERRORS
559 GLint err = this->glGetError();
560 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4f\n", err);
561 #endif
562 DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4f(target:0x%08x s:%f t:%f r:%f q:%f )", stream, var_target, var_s, var_t, var_r, var_q);
563 this->glMultiTexCoord4f(var_target, var_s, var_t, var_r, var_q);
564 SET_LASTCALL("glMultiTexCoord4f");
565 android::base::endTrace();
566 break;
567 }
568 case OP_glNormal3f: {
569 android::base::beginTrace("glNormal3f decode");
570 GLfloat var_nx = Unpack<GLfloat,uint32_t>(ptr + 8);
571 GLfloat var_ny = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
572 GLfloat var_nz = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
573 if (useChecksum) {
574 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
575 "gles1_decoder_context_t::decode, OP_glNormal3f: GL checksumCalculator failure\n");
576 }
577 #ifdef CHECK_GL_ERRORS
578 GLint err = this->glGetError();
579 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3f\n", err);
580 #endif
581 DECODER_DEBUG_LOG("gles1(%p): glNormal3f(nx:%f ny:%f nz:%f )", stream, var_nx, var_ny, var_nz);
582 this->glNormal3f(var_nx, var_ny, var_nz);
583 SET_LASTCALL("glNormal3f");
584 android::base::endTrace();
585 break;
586 }
587 case OP_glOrthof: {
588 android::base::beginTrace("glOrthof decode");
589 GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
590 GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
591 GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
592 GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
593 GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
594 GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
595 if (useChecksum) {
596 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
597 "gles1_decoder_context_t::decode, OP_glOrthof: GL checksumCalculator failure\n");
598 }
599 #ifdef CHECK_GL_ERRORS
600 GLint err = this->glGetError();
601 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthof\n", err);
602 #endif
603 DECODER_DEBUG_LOG("gles1(%p): glOrthof(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
604 this->glOrthof(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
605 SET_LASTCALL("glOrthof");
606 android::base::endTrace();
607 break;
608 }
609 case OP_glPointParameterf: {
610 android::base::beginTrace("glPointParameterf decode");
611 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
612 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
613 if (useChecksum) {
614 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
615 "gles1_decoder_context_t::decode, OP_glPointParameterf: GL checksumCalculator failure\n");
616 }
617 #ifdef CHECK_GL_ERRORS
618 GLint err = this->glGetError();
619 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterf\n", err);
620 #endif
621 DECODER_DEBUG_LOG("gles1(%p): glPointParameterf(pname:0x%08x param:%f )", stream, var_pname, var_param);
622 this->glPointParameterf(var_pname, var_param);
623 SET_LASTCALL("glPointParameterf");
624 android::base::endTrace();
625 break;
626 }
627 case OP_glPointParameterfv: {
628 android::base::beginTrace("glPointParameterfv decode");
629 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
630 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
631 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
632 if (useChecksum) {
633 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
634 "gles1_decoder_context_t::decode, OP_glPointParameterfv: GL checksumCalculator failure\n");
635 }
636 #ifdef CHECK_GL_ERRORS
637 GLint err = this->glGetError();
638 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterfv\n", err);
639 #endif
640 DECODER_DEBUG_LOG("gles1(%p): glPointParameterfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
641 this->glPointParameterfv(var_pname, (const GLfloat*)(inptr_params.get()));
642 SET_LASTCALL("glPointParameterfv");
643 android::base::endTrace();
644 break;
645 }
646 case OP_glPointSize: {
647 android::base::beginTrace("glPointSize decode");
648 GLfloat var_size = Unpack<GLfloat,uint32_t>(ptr + 8);
649 if (useChecksum) {
650 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
651 "gles1_decoder_context_t::decode, OP_glPointSize: GL checksumCalculator failure\n");
652 }
653 #ifdef CHECK_GL_ERRORS
654 GLint err = this->glGetError();
655 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSize\n", err);
656 #endif
657 DECODER_DEBUG_LOG("gles1(%p): glPointSize(size:%f )", stream, var_size);
658 this->glPointSize(var_size);
659 SET_LASTCALL("glPointSize");
660 android::base::endTrace();
661 break;
662 }
663 case OP_glPolygonOffset: {
664 android::base::beginTrace("glPolygonOffset decode");
665 GLfloat var_factor = Unpack<GLfloat,uint32_t>(ptr + 8);
666 GLfloat var_units = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
667 if (useChecksum) {
668 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
669 "gles1_decoder_context_t::decode, OP_glPolygonOffset: GL checksumCalculator failure\n");
670 }
671 #ifdef CHECK_GL_ERRORS
672 GLint err = this->glGetError();
673 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffset\n", err);
674 #endif
675 DECODER_DEBUG_LOG("gles1(%p): glPolygonOffset(factor:%f units:%f )", stream, var_factor, var_units);
676 this->glPolygonOffset(var_factor, var_units);
677 SET_LASTCALL("glPolygonOffset");
678 android::base::endTrace();
679 break;
680 }
681 case OP_glRotatef: {
682 android::base::beginTrace("glRotatef decode");
683 GLfloat var_angle = Unpack<GLfloat,uint32_t>(ptr + 8);
684 GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
685 GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
686 GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
687 if (useChecksum) {
688 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
689 "gles1_decoder_context_t::decode, OP_glRotatef: GL checksumCalculator failure\n");
690 }
691 #ifdef CHECK_GL_ERRORS
692 GLint err = this->glGetError();
693 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatef\n", err);
694 #endif
695 DECODER_DEBUG_LOG("gles1(%p): glRotatef(angle:%f x:%f y:%f z:%f )", stream, var_angle, var_x, var_y, var_z);
696 this->glRotatef(var_angle, var_x, var_y, var_z);
697 SET_LASTCALL("glRotatef");
698 android::base::endTrace();
699 break;
700 }
701 case OP_glScalef: {
702 android::base::beginTrace("glScalef decode");
703 GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
704 GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
705 GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
706 if (useChecksum) {
707 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
708 "gles1_decoder_context_t::decode, OP_glScalef: GL checksumCalculator failure\n");
709 }
710 #ifdef CHECK_GL_ERRORS
711 GLint err = this->glGetError();
712 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalef\n", err);
713 #endif
714 DECODER_DEBUG_LOG("gles1(%p): glScalef(x:%f y:%f z:%f )", stream, var_x, var_y, var_z);
715 this->glScalef(var_x, var_y, var_z);
716 SET_LASTCALL("glScalef");
717 android::base::endTrace();
718 break;
719 }
720 case OP_glTexEnvf: {
721 android::base::beginTrace("glTexEnvf decode");
722 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
723 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
724 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
725 if (useChecksum) {
726 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
727 "gles1_decoder_context_t::decode, OP_glTexEnvf: GL checksumCalculator failure\n");
728 }
729 #ifdef CHECK_GL_ERRORS
730 GLint err = this->glGetError();
731 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvf\n", err);
732 #endif
733 DECODER_DEBUG_LOG("gles1(%p): glTexEnvf(target:0x%08x pname:0x%08x param:%f )", stream, var_target, var_pname, var_param);
734 this->glTexEnvf(var_target, var_pname, var_param);
735 SET_LASTCALL("glTexEnvf");
736 android::base::endTrace();
737 break;
738 }
739 case OP_glTexEnvfv: {
740 android::base::beginTrace("glTexEnvfv decode");
741 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
742 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
743 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
744 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
745 if (useChecksum) {
746 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
747 "gles1_decoder_context_t::decode, OP_glTexEnvfv: GL checksumCalculator failure\n");
748 }
749 #ifdef CHECK_GL_ERRORS
750 GLint err = this->glGetError();
751 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvfv\n", err);
752 #endif
753 DECODER_DEBUG_LOG("gles1(%p): glTexEnvfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
754 this->glTexEnvfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
755 SET_LASTCALL("glTexEnvfv");
756 android::base::endTrace();
757 break;
758 }
759 case OP_glTexParameterf: {
760 android::base::beginTrace("glTexParameterf decode");
761 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
762 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
763 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
764 if (useChecksum) {
765 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
766 "gles1_decoder_context_t::decode, OP_glTexParameterf: GL checksumCalculator failure\n");
767 }
768 #ifdef CHECK_GL_ERRORS
769 GLint err = this->glGetError();
770 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterf\n", err);
771 #endif
772 DECODER_DEBUG_LOG("gles1(%p): glTexParameterf(target:0x%08x pname:0x%08x param:%f )", stream, var_target, var_pname, var_param);
773 this->glTexParameterf(var_target, var_pname, var_param);
774 SET_LASTCALL("glTexParameterf");
775 android::base::endTrace();
776 break;
777 }
778 case OP_glTexParameterfv: {
779 android::base::beginTrace("glTexParameterfv decode");
780 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
781 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
782 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
783 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
784 if (useChecksum) {
785 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
786 "gles1_decoder_context_t::decode, OP_glTexParameterfv: GL checksumCalculator failure\n");
787 }
788 #ifdef CHECK_GL_ERRORS
789 GLint err = this->glGetError();
790 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterfv\n", err);
791 #endif
792 DECODER_DEBUG_LOG("gles1(%p): glTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
793 this->glTexParameterfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
794 SET_LASTCALL("glTexParameterfv");
795 android::base::endTrace();
796 break;
797 }
798 case OP_glTranslatef: {
799 android::base::beginTrace("glTranslatef decode");
800 GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
801 GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
802 GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
803 if (useChecksum) {
804 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
805 "gles1_decoder_context_t::decode, OP_glTranslatef: GL checksumCalculator failure\n");
806 }
807 #ifdef CHECK_GL_ERRORS
808 GLint err = this->glGetError();
809 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatef\n", err);
810 #endif
811 DECODER_DEBUG_LOG("gles1(%p): glTranslatef(x:%f y:%f z:%f )", stream, var_x, var_y, var_z);
812 this->glTranslatef(var_x, var_y, var_z);
813 SET_LASTCALL("glTranslatef");
814 android::base::endTrace();
815 break;
816 }
817 case OP_glActiveTexture: {
818 android::base::beginTrace("glActiveTexture decode");
819 GLenum var_texture = Unpack<GLenum,uint32_t>(ptr + 8);
820 if (useChecksum) {
821 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
822 "gles1_decoder_context_t::decode, OP_glActiveTexture: GL checksumCalculator failure\n");
823 }
824 #ifdef CHECK_GL_ERRORS
825 GLint err = this->glGetError();
826 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glActiveTexture\n", err);
827 #endif
828 DECODER_DEBUG_LOG("gles1(%p): glActiveTexture(texture:0x%08x )", stream, var_texture);
829 this->glActiveTexture(var_texture);
830 SET_LASTCALL("glActiveTexture");
831 android::base::endTrace();
832 break;
833 }
834 case OP_glAlphaFuncx: {
835 android::base::beginTrace("glAlphaFuncx decode");
836 GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
837 GLclampx var_ref = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
838 if (useChecksum) {
839 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
840 "gles1_decoder_context_t::decode, OP_glAlphaFuncx: GL checksumCalculator failure\n");
841 }
842 #ifdef CHECK_GL_ERRORS
843 GLint err = this->glGetError();
844 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFuncx\n", err);
845 #endif
846 DECODER_DEBUG_LOG("gles1(%p): glAlphaFuncx(func:0x%08x ref:0x%08x )", stream, var_func, var_ref);
847 this->glAlphaFuncx(var_func, var_ref);
848 SET_LASTCALL("glAlphaFuncx");
849 android::base::endTrace();
850 break;
851 }
852 case OP_glBindBuffer: {
853 android::base::beginTrace("glBindBuffer decode");
854 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
855 GLuint var_buffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
856 if (useChecksum) {
857 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
858 "gles1_decoder_context_t::decode, OP_glBindBuffer: GL checksumCalculator failure\n");
859 }
860 #ifdef CHECK_GL_ERRORS
861 GLint err = this->glGetError();
862 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindBuffer\n", err);
863 #endif
864 DECODER_DEBUG_LOG("gles1(%p): glBindBuffer(target:0x%08x buffer:%u )", stream, var_target, var_buffer);
865 this->glBindBuffer(var_target, var_buffer);
866 SET_LASTCALL("glBindBuffer");
867 android::base::endTrace();
868 break;
869 }
870 case OP_glBindTexture: {
871 android::base::beginTrace("glBindTexture decode");
872 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
873 GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
874 if (useChecksum) {
875 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
876 "gles1_decoder_context_t::decode, OP_glBindTexture: GL checksumCalculator failure\n");
877 }
878 #ifdef CHECK_GL_ERRORS
879 GLint err = this->glGetError();
880 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindTexture\n", err);
881 #endif
882 DECODER_DEBUG_LOG("gles1(%p): glBindTexture(target:0x%08x texture:%u )", stream, var_target, var_texture);
883 this->glBindTexture(var_target, var_texture);
884 SET_LASTCALL("glBindTexture");
885 android::base::endTrace();
886 break;
887 }
888 case OP_glBlendFunc: {
889 android::base::beginTrace("glBlendFunc decode");
890 GLenum var_sfactor = Unpack<GLenum,uint32_t>(ptr + 8);
891 GLenum var_dfactor = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
892 if (useChecksum) {
893 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
894 "gles1_decoder_context_t::decode, OP_glBlendFunc: GL checksumCalculator failure\n");
895 }
896 #ifdef CHECK_GL_ERRORS
897 GLint err = this->glGetError();
898 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendFunc\n", err);
899 #endif
900 DECODER_DEBUG_LOG("gles1(%p): glBlendFunc(sfactor:0x%08x dfactor:0x%08x )", stream, var_sfactor, var_dfactor);
901 this->glBlendFunc(var_sfactor, var_dfactor);
902 SET_LASTCALL("glBlendFunc");
903 android::base::endTrace();
904 break;
905 }
906 case OP_glBufferData: {
907 android::base::beginTrace("glBufferData decode");
908 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
909 GLsizeiptr var_size = Unpack<GLsizeiptr,uint32_t>(ptr + 8 + 4);
910 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
911 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
912 GLenum var_usage = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
913 if (useChecksum) {
914 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
915 "gles1_decoder_context_t::decode, OP_glBufferData: GL checksumCalculator failure\n");
916 }
917 #ifdef CHECK_GL_ERRORS
918 GLint err = this->glGetError();
919 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBufferData\n", err);
920 #endif
921 DECODER_DEBUG_LOG("gles1(%p): glBufferData(target:0x%08x size:0x%08lx data:%p(%u) usage:0x%08x )", stream, var_target, var_size, (const GLvoid*)(inptr_data.get()), size_data, var_usage);
922 this->glBufferData(var_target, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()), var_usage);
923 SET_LASTCALL("glBufferData");
924 android::base::endTrace();
925 break;
926 }
927 case OP_glBufferSubData: {
928 android::base::beginTrace("glBufferSubData decode");
929 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
930 GLintptr var_offset = Unpack<GLintptr,uint32_t>(ptr + 8 + 4);
931 GLsizeiptr var_size = Unpack<GLsizeiptr,uint32_t>(ptr + 8 + 4 + 4);
932 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
933 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
934 if (useChecksum) {
935 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + size_data, checksumSize,
936 "gles1_decoder_context_t::decode, OP_glBufferSubData: GL checksumCalculator failure\n");
937 }
938 #ifdef CHECK_GL_ERRORS
939 GLint err = this->glGetError();
940 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBufferSubData\n", err);
941 #endif
942 DECODER_DEBUG_LOG("gles1(%p): glBufferSubData(target:0x%08x offset:0x%08lx size:0x%08lx data:%p(%u) )", stream, var_target, var_offset, var_size, (const GLvoid*)(inptr_data.get()), size_data);
943 this->glBufferSubData(var_target, var_offset, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
944 SET_LASTCALL("glBufferSubData");
945 android::base::endTrace();
946 break;
947 }
948 case OP_glClear: {
949 android::base::beginTrace("glClear decode");
950 GLbitfield var_mask = Unpack<GLbitfield,uint32_t>(ptr + 8);
951 if (useChecksum) {
952 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
953 "gles1_decoder_context_t::decode, OP_glClear: GL checksumCalculator failure\n");
954 }
955 #ifdef CHECK_GL_ERRORS
956 GLint err = this->glGetError();
957 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClear\n", err);
958 #endif
959 DECODER_DEBUG_LOG("gles1(%p): glClear(mask:0x%08x )", stream, var_mask);
960 this->glClear(var_mask);
961 SET_LASTCALL("glClear");
962 android::base::endTrace();
963 break;
964 }
965 case OP_glClearColorx: {
966 android::base::beginTrace("glClearColorx decode");
967 GLclampx var_red = Unpack<GLclampx,uint32_t>(ptr + 8);
968 GLclampx var_green = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
969 GLclampx var_blue = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4);
970 GLclampx var_alpha = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4 + 4);
971 if (useChecksum) {
972 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
973 "gles1_decoder_context_t::decode, OP_glClearColorx: GL checksumCalculator failure\n");
974 }
975 #ifdef CHECK_GL_ERRORS
976 GLint err = this->glGetError();
977 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColorx\n", err);
978 #endif
979 DECODER_DEBUG_LOG("gles1(%p): glClearColorx(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
980 this->glClearColorx(var_red, var_green, var_blue, var_alpha);
981 SET_LASTCALL("glClearColorx");
982 android::base::endTrace();
983 break;
984 }
985 case OP_glClearDepthx: {
986 android::base::beginTrace("glClearDepthx decode");
987 GLclampx var_depth = Unpack<GLclampx,uint32_t>(ptr + 8);
988 if (useChecksum) {
989 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
990 "gles1_decoder_context_t::decode, OP_glClearDepthx: GL checksumCalculator failure\n");
991 }
992 #ifdef CHECK_GL_ERRORS
993 GLint err = this->glGetError();
994 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthx\n", err);
995 #endif
996 DECODER_DEBUG_LOG("gles1(%p): glClearDepthx(depth:0x%08x )", stream, var_depth);
997 this->glClearDepthx(var_depth);
998 SET_LASTCALL("glClearDepthx");
999 android::base::endTrace();
1000 break;
1001 }
1002 case OP_glClearStencil: {
1003 android::base::beginTrace("glClearStencil decode");
1004 GLint var_s = Unpack<GLint,uint32_t>(ptr + 8);
1005 if (useChecksum) {
1006 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1007 "gles1_decoder_context_t::decode, OP_glClearStencil: GL checksumCalculator failure\n");
1008 }
1009 #ifdef CHECK_GL_ERRORS
1010 GLint err = this->glGetError();
1011 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearStencil\n", err);
1012 #endif
1013 DECODER_DEBUG_LOG("gles1(%p): glClearStencil(s:%d )", stream, var_s);
1014 this->glClearStencil(var_s);
1015 SET_LASTCALL("glClearStencil");
1016 android::base::endTrace();
1017 break;
1018 }
1019 case OP_glClientActiveTexture: {
1020 android::base::beginTrace("glClientActiveTexture decode");
1021 GLenum var_texture = Unpack<GLenum,uint32_t>(ptr + 8);
1022 if (useChecksum) {
1023 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1024 "gles1_decoder_context_t::decode, OP_glClientActiveTexture: GL checksumCalculator failure\n");
1025 }
1026 #ifdef CHECK_GL_ERRORS
1027 GLint err = this->glGetError();
1028 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClientActiveTexture\n", err);
1029 #endif
1030 DECODER_DEBUG_LOG("gles1(%p): glClientActiveTexture(texture:0x%08x )", stream, var_texture);
1031 this->glClientActiveTexture(var_texture);
1032 SET_LASTCALL("glClientActiveTexture");
1033 android::base::endTrace();
1034 break;
1035 }
1036 case OP_glColor4ub: {
1037 android::base::beginTrace("glColor4ub decode");
1038 GLubyte var_red = Unpack<GLubyte,uint8_t>(ptr + 8);
1039 GLubyte var_green = Unpack<GLubyte,uint8_t>(ptr + 8 + 1);
1040 GLubyte var_blue = Unpack<GLubyte,uint8_t>(ptr + 8 + 1 + 1);
1041 GLubyte var_alpha = Unpack<GLubyte,uint8_t>(ptr + 8 + 1 + 1 + 1);
1042 if (useChecksum) {
1043 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1 + 1 + 1 + 1, ptr + 8 + 1 + 1 + 1 + 1, checksumSize,
1044 "gles1_decoder_context_t::decode, OP_glColor4ub: GL checksumCalculator failure\n");
1045 }
1046 #ifdef CHECK_GL_ERRORS
1047 GLint err = this->glGetError();
1048 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4ub\n", err);
1049 #endif
1050 DECODER_DEBUG_LOG("gles1(%p): glColor4ub(red:0x%02x green:0x%02x blue:0x%02x alpha:0x%02x )", stream, var_red, var_green, var_blue, var_alpha);
1051 this->glColor4ub(var_red, var_green, var_blue, var_alpha);
1052 SET_LASTCALL("glColor4ub");
1053 android::base::endTrace();
1054 break;
1055 }
1056 case OP_glColor4x: {
1057 android::base::beginTrace("glColor4x decode");
1058 GLfixed var_red = Unpack<GLfixed,uint32_t>(ptr + 8);
1059 GLfixed var_green = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
1060 GLfixed var_blue = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
1061 GLfixed var_alpha = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
1062 if (useChecksum) {
1063 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
1064 "gles1_decoder_context_t::decode, OP_glColor4x: GL checksumCalculator failure\n");
1065 }
1066 #ifdef CHECK_GL_ERRORS
1067 GLint err = this->glGetError();
1068 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4x\n", err);
1069 #endif
1070 DECODER_DEBUG_LOG("gles1(%p): glColor4x(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
1071 this->glColor4x(var_red, var_green, var_blue, var_alpha);
1072 SET_LASTCALL("glColor4x");
1073 android::base::endTrace();
1074 break;
1075 }
1076 case OP_glColorMask: {
1077 android::base::beginTrace("glColorMask decode");
1078 GLboolean var_red = Unpack<GLboolean,uint8_t>(ptr + 8);
1079 GLboolean var_green = Unpack<GLboolean,uint8_t>(ptr + 8 + 1);
1080 GLboolean var_blue = Unpack<GLboolean,uint8_t>(ptr + 8 + 1 + 1);
1081 GLboolean var_alpha = Unpack<GLboolean,uint8_t>(ptr + 8 + 1 + 1 + 1);
1082 if (useChecksum) {
1083 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1 + 1 + 1 + 1, ptr + 8 + 1 + 1 + 1 + 1, checksumSize,
1084 "gles1_decoder_context_t::decode, OP_glColorMask: GL checksumCalculator failure\n");
1085 }
1086 #ifdef CHECK_GL_ERRORS
1087 GLint err = this->glGetError();
1088 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorMask\n", err);
1089 #endif
1090 DECODER_DEBUG_LOG("gles1(%p): glColorMask(red:%d green:%d blue:%d alpha:%d )", stream, var_red, var_green, var_blue, var_alpha);
1091 this->glColorMask(var_red, var_green, var_blue, var_alpha);
1092 SET_LASTCALL("glColorMask");
1093 android::base::endTrace();
1094 break;
1095 }
1096 case OP_glColorPointer: {
1097 android::base::beginTrace("glColorPointer decode");
1098 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
1099 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1100 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
1101 uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
1102 InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
1103 if (useChecksum) {
1104 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
1105 "gles1_decoder_context_t::decode, OP_glColorPointer: GL checksumCalculator failure\n");
1106 }
1107 #ifdef CHECK_GL_ERRORS
1108 GLint err = this->glGetError();
1109 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointer\n", err);
1110 #endif
1111 DECODER_DEBUG_LOG("gles1(%p): glColorPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
1112 this->glColorPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
1113 SET_LASTCALL("glColorPointer");
1114 android::base::endTrace();
1115 break;
1116 }
1117 case OP_glCompressedTexImage2D: {
1118 android::base::beginTrace("glCompressedTexImage2D decode");
1119 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1120 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1121 GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
1122 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
1123 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1124 GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1125 GLsizei var_imageSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1126 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1127 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_data);
1128 if (useChecksum) {
1129 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,
1130 "gles1_decoder_context_t::decode, OP_glCompressedTexImage2D: GL checksumCalculator failure\n");
1131 }
1132 #ifdef CHECK_GL_ERRORS
1133 GLint err = this->glGetError();
1134 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCompressedTexImage2D\n", err);
1135 #endif
1136 DECODER_DEBUG_LOG("gles1(%p): glCompressedTexImage2D(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d border:%d imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
1137 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()));
1138 SET_LASTCALL("glCompressedTexImage2D");
1139 android::base::endTrace();
1140 break;
1141 }
1142 case OP_glCompressedTexSubImage2D: {
1143 android::base::beginTrace("glCompressedTexSubImage2D decode");
1144 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1145 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1146 GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
1147 GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
1148 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1149 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1150 GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1151 GLsizei var_imageSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1152 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1153 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_data);
1154 if (useChecksum) {
1155 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,
1156 "gles1_decoder_context_t::decode, OP_glCompressedTexSubImage2D: GL checksumCalculator failure\n");
1157 }
1158 #ifdef CHECK_GL_ERRORS
1159 GLint err = this->glGetError();
1160 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCompressedTexSubImage2D\n", err);
1161 #endif
1162 DECODER_DEBUG_LOG("gles1(%p): glCompressedTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
1163 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()));
1164 SET_LASTCALL("glCompressedTexSubImage2D");
1165 android::base::endTrace();
1166 break;
1167 }
1168 case OP_glCopyTexImage2D: {
1169 android::base::beginTrace("glCopyTexImage2D decode");
1170 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1171 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1172 GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
1173 GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
1174 GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1175 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1176 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1177 GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1178 if (useChecksum) {
1179 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
1180 "gles1_decoder_context_t::decode, OP_glCopyTexImage2D: GL checksumCalculator failure\n");
1181 }
1182 #ifdef CHECK_GL_ERRORS
1183 GLint err = this->glGetError();
1184 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCopyTexImage2D\n", err);
1185 #endif
1186 DECODER_DEBUG_LOG("gles1(%p): glCopyTexImage2D(target:0x%08x level:%d internalformat:0x%08x x:%d y:%d width:%d height:%d border:%d )", stream, var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
1187 this->glCopyTexImage2D(var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
1188 SET_LASTCALL("glCopyTexImage2D");
1189 android::base::endTrace();
1190 break;
1191 }
1192 case OP_glCopyTexSubImage2D: {
1193 android::base::beginTrace("glCopyTexSubImage2D decode");
1194 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1195 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1196 GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
1197 GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
1198 GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1199 GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1200 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1201 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1202 if (useChecksum) {
1203 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
1204 "gles1_decoder_context_t::decode, OP_glCopyTexSubImage2D: GL checksumCalculator failure\n");
1205 }
1206 #ifdef CHECK_GL_ERRORS
1207 GLint err = this->glGetError();
1208 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCopyTexSubImage2D\n", err);
1209 #endif
1210 DECODER_DEBUG_LOG("gles1(%p): glCopyTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d x:%d y:%d width:%d height:%d )", stream, var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
1211 this->glCopyTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
1212 SET_LASTCALL("glCopyTexSubImage2D");
1213 android::base::endTrace();
1214 break;
1215 }
1216 case OP_glCullFace: {
1217 android::base::beginTrace("glCullFace decode");
1218 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1219 if (useChecksum) {
1220 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1221 "gles1_decoder_context_t::decode, OP_glCullFace: GL checksumCalculator failure\n");
1222 }
1223 #ifdef CHECK_GL_ERRORS
1224 GLint err = this->glGetError();
1225 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCullFace\n", err);
1226 #endif
1227 DECODER_DEBUG_LOG("gles1(%p): glCullFace(mode:0x%08x )", stream, var_mode);
1228 this->glCullFace(var_mode);
1229 SET_LASTCALL("glCullFace");
1230 android::base::endTrace();
1231 break;
1232 }
1233 case OP_glDeleteBuffers: {
1234 android::base::beginTrace("glDeleteBuffers decode");
1235 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1236 uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1237 InputBuffer inptr_buffers(ptr + 8 + 4 + 4, size_buffers);
1238 if (useChecksum) {
1239 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_buffers, ptr + 8 + 4 + 4 + size_buffers, checksumSize,
1240 "gles1_decoder_context_t::decode, OP_glDeleteBuffers: GL checksumCalculator failure\n");
1241 }
1242 #ifdef CHECK_GL_ERRORS
1243 GLint err = this->glGetError();
1244 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteBuffers\n", err);
1245 #endif
1246 DECODER_DEBUG_LOG("gles1(%p): glDeleteBuffers(n:%d buffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_buffers.get()), size_buffers);
1247 this->glDeleteBuffers_dec(this, var_n, (const GLuint*)(inptr_buffers.get()));
1248 SET_LASTCALL("glDeleteBuffers");
1249 android::base::endTrace();
1250 break;
1251 }
1252 case OP_glDeleteTextures: {
1253 android::base::beginTrace("glDeleteTextures decode");
1254 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1255 uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1256 InputBuffer inptr_textures(ptr + 8 + 4 + 4, size_textures);
1257 if (useChecksum) {
1258 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_textures, ptr + 8 + 4 + 4 + size_textures, checksumSize,
1259 "gles1_decoder_context_t::decode, OP_glDeleteTextures: GL checksumCalculator failure\n");
1260 }
1261 #ifdef CHECK_GL_ERRORS
1262 GLint err = this->glGetError();
1263 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteTextures\n", err);
1264 #endif
1265 DECODER_DEBUG_LOG("gles1(%p): glDeleteTextures(n:%d textures:%p(%u) )", stream, var_n, (const GLuint*)(inptr_textures.get()), size_textures);
1266 this->glDeleteTextures_dec(this, var_n, (const GLuint*)(inptr_textures.get()));
1267 SET_LASTCALL("glDeleteTextures");
1268 android::base::endTrace();
1269 break;
1270 }
1271 case OP_glDepthFunc: {
1272 android::base::beginTrace("glDepthFunc decode");
1273 GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
1274 if (useChecksum) {
1275 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1276 "gles1_decoder_context_t::decode, OP_glDepthFunc: GL checksumCalculator failure\n");
1277 }
1278 #ifdef CHECK_GL_ERRORS
1279 GLint err = this->glGetError();
1280 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthFunc\n", err);
1281 #endif
1282 DECODER_DEBUG_LOG("gles1(%p): glDepthFunc(func:0x%08x )", stream, var_func);
1283 this->glDepthFunc(var_func);
1284 SET_LASTCALL("glDepthFunc");
1285 android::base::endTrace();
1286 break;
1287 }
1288 case OP_glDepthMask: {
1289 android::base::beginTrace("glDepthMask decode");
1290 GLboolean var_flag = Unpack<GLboolean,uint8_t>(ptr + 8);
1291 if (useChecksum) {
1292 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1, ptr + 8 + 1, checksumSize,
1293 "gles1_decoder_context_t::decode, OP_glDepthMask: GL checksumCalculator failure\n");
1294 }
1295 #ifdef CHECK_GL_ERRORS
1296 GLint err = this->glGetError();
1297 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthMask\n", err);
1298 #endif
1299 DECODER_DEBUG_LOG("gles1(%p): glDepthMask(flag:%d )", stream, var_flag);
1300 this->glDepthMask(var_flag);
1301 SET_LASTCALL("glDepthMask");
1302 android::base::endTrace();
1303 break;
1304 }
1305 case OP_glDepthRangex: {
1306 android::base::beginTrace("glDepthRangex decode");
1307 GLclampx var_zNear = Unpack<GLclampx,uint32_t>(ptr + 8);
1308 GLclampx var_zFar = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
1309 if (useChecksum) {
1310 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1311 "gles1_decoder_context_t::decode, OP_glDepthRangex: GL checksumCalculator failure\n");
1312 }
1313 #ifdef CHECK_GL_ERRORS
1314 GLint err = this->glGetError();
1315 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangex\n", err);
1316 #endif
1317 DECODER_DEBUG_LOG("gles1(%p): glDepthRangex(zNear:0x%08x zFar:0x%08x )", stream, var_zNear, var_zFar);
1318 this->glDepthRangex(var_zNear, var_zFar);
1319 SET_LASTCALL("glDepthRangex");
1320 android::base::endTrace();
1321 break;
1322 }
1323 case OP_glDisable: {
1324 android::base::beginTrace("glDisable decode");
1325 GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
1326 if (useChecksum) {
1327 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1328 "gles1_decoder_context_t::decode, OP_glDisable: GL checksumCalculator failure\n");
1329 }
1330 #ifdef CHECK_GL_ERRORS
1331 GLint err = this->glGetError();
1332 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisable\n", err);
1333 #endif
1334 DECODER_DEBUG_LOG("gles1(%p): glDisable(cap:0x%08x )", stream, var_cap);
1335 this->glDisable(var_cap);
1336 SET_LASTCALL("glDisable");
1337 android::base::endTrace();
1338 break;
1339 }
1340 case OP_glDisableClientState: {
1341 android::base::beginTrace("glDisableClientState decode");
1342 GLenum var_array = Unpack<GLenum,uint32_t>(ptr + 8);
1343 if (useChecksum) {
1344 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1345 "gles1_decoder_context_t::decode, OP_glDisableClientState: GL checksumCalculator failure\n");
1346 }
1347 #ifdef CHECK_GL_ERRORS
1348 GLint err = this->glGetError();
1349 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisableClientState\n", err);
1350 #endif
1351 DECODER_DEBUG_LOG("gles1(%p): glDisableClientState(array:0x%08x )", stream, var_array);
1352 this->glDisableClientState(var_array);
1353 SET_LASTCALL("glDisableClientState");
1354 android::base::endTrace();
1355 break;
1356 }
1357 case OP_glDrawArrays: {
1358 android::base::beginTrace("glDrawArrays decode");
1359 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1360 GLint var_first = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1361 GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
1362 if (useChecksum) {
1363 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1364 "gles1_decoder_context_t::decode, OP_glDrawArrays: GL checksumCalculator failure\n");
1365 }
1366 #ifdef CHECK_GL_ERRORS
1367 GLint err = this->glGetError();
1368 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawArrays\n", err);
1369 #endif
1370 DECODER_DEBUG_LOG("gles1(%p): glDrawArrays(mode:0x%08x first:%d count:%d )", stream, var_mode, var_first, var_count);
1371 this->glDrawArrays(var_mode, var_first, var_count);
1372 SET_LASTCALL("glDrawArrays");
1373 android::base::endTrace();
1374 break;
1375 }
1376 case OP_glDrawElements: {
1377 android::base::beginTrace("glDrawElements decode");
1378 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1379 GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
1380 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
1381 uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
1382 InputBuffer inptr_indices(ptr + 8 + 4 + 4 + 4 + 4, size_indices);
1383 if (useChecksum) {
1384 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_indices, ptr + 8 + 4 + 4 + 4 + 4 + size_indices, checksumSize,
1385 "gles1_decoder_context_t::decode, OP_glDrawElements: GL checksumCalculator failure\n");
1386 }
1387 #ifdef CHECK_GL_ERRORS
1388 GLint err = this->glGetError();
1389 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElements\n", err);
1390 #endif
1391 DECODER_DEBUG_LOG("gles1(%p): glDrawElements(mode:0x%08x count:%d type:0x%08x indices:%p(%u) )", stream, var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()), size_indices);
1392 this->glDrawElements(var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()));
1393 SET_LASTCALL("glDrawElements");
1394 android::base::endTrace();
1395 break;
1396 }
1397 case OP_glEnable: {
1398 android::base::beginTrace("glEnable decode");
1399 GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
1400 if (useChecksum) {
1401 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1402 "gles1_decoder_context_t::decode, OP_glEnable: GL checksumCalculator failure\n");
1403 }
1404 #ifdef CHECK_GL_ERRORS
1405 GLint err = this->glGetError();
1406 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnable\n", err);
1407 #endif
1408 DECODER_DEBUG_LOG("gles1(%p): glEnable(cap:0x%08x )", stream, var_cap);
1409 this->glEnable(var_cap);
1410 SET_LASTCALL("glEnable");
1411 android::base::endTrace();
1412 break;
1413 }
1414 case OP_glEnableClientState: {
1415 android::base::beginTrace("glEnableClientState decode");
1416 GLenum var_array = Unpack<GLenum,uint32_t>(ptr + 8);
1417 if (useChecksum) {
1418 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1419 "gles1_decoder_context_t::decode, OP_glEnableClientState: GL checksumCalculator failure\n");
1420 }
1421 #ifdef CHECK_GL_ERRORS
1422 GLint err = this->glGetError();
1423 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnableClientState\n", err);
1424 #endif
1425 DECODER_DEBUG_LOG("gles1(%p): glEnableClientState(array:0x%08x )", stream, var_array);
1426 this->glEnableClientState(var_array);
1427 SET_LASTCALL("glEnableClientState");
1428 android::base::endTrace();
1429 break;
1430 }
1431 case OP_glFinish: {
1432 android::base::beginTrace("glFinish decode");
1433 if (useChecksum) {
1434 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
1435 "gles1_decoder_context_t::decode, OP_glFinish: GL checksumCalculator failure\n");
1436 }
1437 #ifdef CHECK_GL_ERRORS
1438 GLint err = this->glGetError();
1439 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinish\n", err);
1440 #endif
1441 DECODER_DEBUG_LOG("gles1(%p): glFinish()", stream);
1442 this->glFinish();
1443 SET_LASTCALL("glFinish");
1444 android::base::endTrace();
1445 break;
1446 }
1447 case OP_glFlush: {
1448 android::base::beginTrace("glFlush decode");
1449 if (useChecksum) {
1450 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
1451 "gles1_decoder_context_t::decode, OP_glFlush: GL checksumCalculator failure\n");
1452 }
1453 #ifdef CHECK_GL_ERRORS
1454 GLint err = this->glGetError();
1455 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFlush\n", err);
1456 #endif
1457 DECODER_DEBUG_LOG("gles1(%p): glFlush()", stream);
1458 this->glFlush();
1459 SET_LASTCALL("glFlush");
1460 android::base::endTrace();
1461 break;
1462 }
1463 case OP_glFogx: {
1464 android::base::beginTrace("glFogx decode");
1465 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1466 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
1467 if (useChecksum) {
1468 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1469 "gles1_decoder_context_t::decode, OP_glFogx: GL checksumCalculator failure\n");
1470 }
1471 #ifdef CHECK_GL_ERRORS
1472 GLint err = this->glGetError();
1473 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogx\n", err);
1474 #endif
1475 DECODER_DEBUG_LOG("gles1(%p): glFogx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
1476 this->glFogx(var_pname, var_param);
1477 SET_LASTCALL("glFogx");
1478 android::base::endTrace();
1479 break;
1480 }
1481 case OP_glFogxv: {
1482 android::base::beginTrace("glFogxv decode");
1483 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1484 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1485 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
1486 if (useChecksum) {
1487 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
1488 "gles1_decoder_context_t::decode, OP_glFogxv: GL checksumCalculator failure\n");
1489 }
1490 #ifdef CHECK_GL_ERRORS
1491 GLint err = this->glGetError();
1492 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxv\n", err);
1493 #endif
1494 DECODER_DEBUG_LOG("gles1(%p): glFogxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
1495 this->glFogxv(var_pname, (const GLfixed*)(inptr_params.get()));
1496 SET_LASTCALL("glFogxv");
1497 android::base::endTrace();
1498 break;
1499 }
1500 case OP_glFrontFace: {
1501 android::base::beginTrace("glFrontFace decode");
1502 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1503 if (useChecksum) {
1504 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1505 "gles1_decoder_context_t::decode, OP_glFrontFace: GL checksumCalculator failure\n");
1506 }
1507 #ifdef CHECK_GL_ERRORS
1508 GLint err = this->glGetError();
1509 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrontFace\n", err);
1510 #endif
1511 DECODER_DEBUG_LOG("gles1(%p): glFrontFace(mode:0x%08x )", stream, var_mode);
1512 this->glFrontFace(var_mode);
1513 SET_LASTCALL("glFrontFace");
1514 android::base::endTrace();
1515 break;
1516 }
1517 case OP_glFrustumx: {
1518 android::base::beginTrace("glFrustumx decode");
1519 GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
1520 GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
1521 GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
1522 GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
1523 GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1524 GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1525 if (useChecksum) {
1526 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
1527 "gles1_decoder_context_t::decode, OP_glFrustumx: GL checksumCalculator failure\n");
1528 }
1529 #ifdef CHECK_GL_ERRORS
1530 GLint err = this->glGetError();
1531 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumx\n", err);
1532 #endif
1533 DECODER_DEBUG_LOG("gles1(%p): glFrustumx(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
1534 this->glFrustumx(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
1535 SET_LASTCALL("glFrustumx");
1536 android::base::endTrace();
1537 break;
1538 }
1539 case OP_glGetBooleanv: {
1540 android::base::beginTrace("glGetBooleanv decode");
1541 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1542 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1543 if (useChecksum) {
1544 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1545 "gles1_decoder_context_t::decode, OP_glGetBooleanv: GL checksumCalculator failure\n");
1546 }
1547 size_t totalTmpSize = size_params;
1548 totalTmpSize += checksumSize;
1549 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1550 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1551 #ifdef CHECK_GL_ERRORS
1552 GLint err = this->glGetError();
1553 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBooleanv\n", err);
1554 #endif
1555 DECODER_DEBUG_LOG("gles1(%p): glGetBooleanv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLboolean*)(outptr_params.get()), size_params);
1556 this->glGetBooleanv(var_pname, (GLboolean*)(outptr_params.get()));
1557 outptr_params.flush();
1558 if (useChecksum) {
1559 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1560 }
1561 stream->flush();
1562 SET_LASTCALL("glGetBooleanv");
1563 android::base::endTrace();
1564 break;
1565 }
1566 case OP_glGetBufferParameteriv: {
1567 android::base::beginTrace("glGetBufferParameteriv decode");
1568 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1569 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1570 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1571 if (useChecksum) {
1572 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1573 "gles1_decoder_context_t::decode, OP_glGetBufferParameteriv: GL checksumCalculator failure\n");
1574 }
1575 size_t totalTmpSize = size_params;
1576 totalTmpSize += checksumSize;
1577 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1578 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1579 #ifdef CHECK_GL_ERRORS
1580 GLint err = this->glGetError();
1581 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBufferParameteriv\n", err);
1582 #endif
1583 DECODER_DEBUG_LOG("gles1(%p): glGetBufferParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
1584 this->glGetBufferParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
1585 outptr_params.flush();
1586 if (useChecksum) {
1587 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1588 }
1589 stream->flush();
1590 SET_LASTCALL("glGetBufferParameteriv");
1591 android::base::endTrace();
1592 break;
1593 }
1594 case OP_glClipPlanex: {
1595 android::base::beginTrace("glClipPlanex decode");
1596 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1597 uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1598 InputBuffer inptr_eqn(ptr + 8 + 4 + 4, size_eqn);
1599 if (useChecksum) {
1600 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_eqn, ptr + 8 + 4 + 4 + size_eqn, checksumSize,
1601 "gles1_decoder_context_t::decode, OP_glClipPlanex: GL checksumCalculator failure\n");
1602 }
1603 #ifdef CHECK_GL_ERRORS
1604 GLint err = this->glGetError();
1605 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanex\n", err);
1606 #endif
1607 DECODER_DEBUG_LOG("gles1(%p): glClipPlanex(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_eqn.get()), size_eqn);
1608 this->glClipPlanex(var_pname, (const GLfixed*)(inptr_eqn.get()));
1609 SET_LASTCALL("glClipPlanex");
1610 android::base::endTrace();
1611 break;
1612 }
1613 case OP_glGenBuffers: {
1614 android::base::beginTrace("glGenBuffers decode");
1615 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1616 uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1617 if (useChecksum) {
1618 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1619 "gles1_decoder_context_t::decode, OP_glGenBuffers: GL checksumCalculator failure\n");
1620 }
1621 size_t totalTmpSize = size_buffers;
1622 totalTmpSize += checksumSize;
1623 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1624 OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
1625 #ifdef CHECK_GL_ERRORS
1626 GLint err = this->glGetError();
1627 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenBuffers\n", err);
1628 #endif
1629 DECODER_DEBUG_LOG("gles1(%p): glGenBuffers(n:%d buffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_buffers.get()), size_buffers);
1630 this->glGenBuffers_dec(this, var_n, (GLuint*)(outptr_buffers.get()));
1631 outptr_buffers.flush();
1632 if (useChecksum) {
1633 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1634 }
1635 stream->flush();
1636 SET_LASTCALL("glGenBuffers");
1637 android::base::endTrace();
1638 break;
1639 }
1640 case OP_glGenTextures: {
1641 android::base::beginTrace("glGenTextures decode");
1642 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1643 uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1644 if (useChecksum) {
1645 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1646 "gles1_decoder_context_t::decode, OP_glGenTextures: GL checksumCalculator failure\n");
1647 }
1648 size_t totalTmpSize = size_textures;
1649 totalTmpSize += checksumSize;
1650 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1651 OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
1652 #ifdef CHECK_GL_ERRORS
1653 GLint err = this->glGetError();
1654 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenTextures\n", err);
1655 #endif
1656 DECODER_DEBUG_LOG("gles1(%p): glGenTextures(n:%d textures:%p(%u) )", stream, var_n, (GLuint*)(outptr_textures.get()), size_textures);
1657 this->glGenTextures_dec(this, var_n, (GLuint*)(outptr_textures.get()));
1658 outptr_textures.flush();
1659 if (useChecksum) {
1660 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1661 }
1662 stream->flush();
1663 SET_LASTCALL("glGenTextures");
1664 android::base::endTrace();
1665 break;
1666 }
1667 case OP_glGetError: {
1668 android::base::beginTrace("glGetError decode");
1669 if (useChecksum) {
1670 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
1671 "gles1_decoder_context_t::decode, OP_glGetError: GL checksumCalculator failure\n");
1672 }
1673 size_t totalTmpSize = sizeof(GLenum);
1674 totalTmpSize += checksumSize;
1675 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1676 #ifdef CHECK_GL_ERRORS
1677 GLint err = this->glGetError();
1678 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetError\n", err);
1679 #endif
1680 DECODER_DEBUG_LOG("gles1(%p): glGetError()", stream);
1681 *(GLenum *)(&tmpBuf[0]) = this->glGetError();
1682 if (useChecksum) {
1683 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1684 }
1685 stream->flush();
1686 SET_LASTCALL("glGetError");
1687 android::base::endTrace();
1688 break;
1689 }
1690 case OP_glGetFixedv: {
1691 android::base::beginTrace("glGetFixedv decode");
1692 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1693 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1694 if (useChecksum) {
1695 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1696 "gles1_decoder_context_t::decode, OP_glGetFixedv: GL checksumCalculator failure\n");
1697 }
1698 size_t totalTmpSize = size_params;
1699 totalTmpSize += checksumSize;
1700 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1701 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1702 #ifdef CHECK_GL_ERRORS
1703 GLint err = this->glGetError();
1704 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFixedv\n", err);
1705 #endif
1706 DECODER_DEBUG_LOG("gles1(%p): glGetFixedv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1707 this->glGetFixedv(var_pname, (GLfixed*)(outptr_params.get()));
1708 outptr_params.flush();
1709 if (useChecksum) {
1710 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1711 }
1712 stream->flush();
1713 SET_LASTCALL("glGetFixedv");
1714 android::base::endTrace();
1715 break;
1716 }
1717 case OP_glGetIntegerv: {
1718 android::base::beginTrace("glGetIntegerv decode");
1719 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1720 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1721 if (useChecksum) {
1722 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1723 "gles1_decoder_context_t::decode, OP_glGetIntegerv: GL checksumCalculator failure\n");
1724 }
1725 size_t totalTmpSize = size_params;
1726 totalTmpSize += checksumSize;
1727 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1728 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1729 #ifdef CHECK_GL_ERRORS
1730 GLint err = this->glGetError();
1731 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetIntegerv\n", err);
1732 #endif
1733 DECODER_DEBUG_LOG("gles1(%p): glGetIntegerv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLint*)(outptr_params.get()), size_params);
1734 this->glGetIntegerv(var_pname, (GLint*)(outptr_params.get()));
1735 outptr_params.flush();
1736 if (useChecksum) {
1737 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1738 }
1739 stream->flush();
1740 SET_LASTCALL("glGetIntegerv");
1741 android::base::endTrace();
1742 break;
1743 }
1744 case OP_glGetLightxv: {
1745 android::base::beginTrace("glGetLightxv decode");
1746 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
1747 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1748 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1749 if (useChecksum) {
1750 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1751 "gles1_decoder_context_t::decode, OP_glGetLightxv: GL checksumCalculator failure\n");
1752 }
1753 size_t totalTmpSize = size_params;
1754 totalTmpSize += checksumSize;
1755 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1756 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1757 #ifdef CHECK_GL_ERRORS
1758 GLint err = this->glGetError();
1759 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightxv\n", err);
1760 #endif
1761 DECODER_DEBUG_LOG("gles1(%p): glGetLightxv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1762 this->glGetLightxv(var_light, var_pname, (GLfixed*)(outptr_params.get()));
1763 outptr_params.flush();
1764 if (useChecksum) {
1765 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1766 }
1767 stream->flush();
1768 SET_LASTCALL("glGetLightxv");
1769 android::base::endTrace();
1770 break;
1771 }
1772 case OP_glGetMaterialxv: {
1773 android::base::beginTrace("glGetMaterialxv decode");
1774 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
1775 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1776 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1777 if (useChecksum) {
1778 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1779 "gles1_decoder_context_t::decode, OP_glGetMaterialxv: GL checksumCalculator failure\n");
1780 }
1781 size_t totalTmpSize = size_params;
1782 totalTmpSize += checksumSize;
1783 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1784 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1785 #ifdef CHECK_GL_ERRORS
1786 GLint err = this->glGetError();
1787 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialxv\n", err);
1788 #endif
1789 DECODER_DEBUG_LOG("gles1(%p): glGetMaterialxv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1790 this->glGetMaterialxv(var_face, var_pname, (GLfixed*)(outptr_params.get()));
1791 outptr_params.flush();
1792 if (useChecksum) {
1793 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1794 }
1795 stream->flush();
1796 SET_LASTCALL("glGetMaterialxv");
1797 android::base::endTrace();
1798 break;
1799 }
1800 case OP_glGetPointerv: {
1801 android::base::beginTrace("glGetPointerv decode");
1802 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1803 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1804 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
1805 if (useChecksum) {
1806 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
1807 "gles1_decoder_context_t::decode, OP_glGetPointerv: GL checksumCalculator failure\n");
1808 }
1809 #ifdef CHECK_GL_ERRORS
1810 GLint err = this->glGetError();
1811 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetPointerv\n", err);
1812 #endif
1813 DECODER_DEBUG_LOG("gles1(%p): glGetPointerv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLvoid**)(inptr_params.get()), size_params);
1814 this->glGetPointerv(var_pname, (GLvoid**)(inptr_params.get()));
1815 SET_LASTCALL("glGetPointerv");
1816 android::base::endTrace();
1817 break;
1818 }
1819 case OP_glGetString: {
1820 android::base::beginTrace("glGetString decode");
1821 GLenum var_name = Unpack<GLenum,uint32_t>(ptr + 8);
1822 if (useChecksum) {
1823 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1824 "gles1_decoder_context_t::decode, OP_glGetString: GL checksumCalculator failure\n");
1825 }
1826 #ifdef CHECK_GL_ERRORS
1827 GLint err = this->glGetError();
1828 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetString\n", err);
1829 #endif
1830 DECODER_DEBUG_LOG("gles1(%p): glGetString(name:0x%08x )", stream, var_name);
1831 this->glGetString(var_name);
1832 SET_LASTCALL("glGetString");
1833 android::base::endTrace();
1834 break;
1835 }
1836 case OP_glGetTexEnviv: {
1837 android::base::beginTrace("glGetTexEnviv decode");
1838 GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
1839 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1840 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1841 if (useChecksum) {
1842 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1843 "gles1_decoder_context_t::decode, OP_glGetTexEnviv: GL checksumCalculator failure\n");
1844 }
1845 size_t totalTmpSize = size_params;
1846 totalTmpSize += checksumSize;
1847 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1848 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1849 #ifdef CHECK_GL_ERRORS
1850 GLint err = this->glGetError();
1851 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnviv\n", err);
1852 #endif
1853 DECODER_DEBUG_LOG("gles1(%p): glGetTexEnviv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLint*)(outptr_params.get()), size_params);
1854 this->glGetTexEnviv(var_env, var_pname, (GLint*)(outptr_params.get()));
1855 outptr_params.flush();
1856 if (useChecksum) {
1857 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1858 }
1859 stream->flush();
1860 SET_LASTCALL("glGetTexEnviv");
1861 android::base::endTrace();
1862 break;
1863 }
1864 case OP_glGetTexEnvxv: {
1865 android::base::beginTrace("glGetTexEnvxv decode");
1866 GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
1867 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1868 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1869 if (useChecksum) {
1870 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1871 "gles1_decoder_context_t::decode, OP_glGetTexEnvxv: GL checksumCalculator failure\n");
1872 }
1873 size_t totalTmpSize = size_params;
1874 totalTmpSize += checksumSize;
1875 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1876 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1877 #ifdef CHECK_GL_ERRORS
1878 GLint err = this->glGetError();
1879 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvxv\n", err);
1880 #endif
1881 DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvxv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1882 this->glGetTexEnvxv(var_env, var_pname, (GLfixed*)(outptr_params.get()));
1883 outptr_params.flush();
1884 if (useChecksum) {
1885 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1886 }
1887 stream->flush();
1888 SET_LASTCALL("glGetTexEnvxv");
1889 android::base::endTrace();
1890 break;
1891 }
1892 case OP_glGetTexParameteriv: {
1893 android::base::beginTrace("glGetTexParameteriv decode");
1894 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1895 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1896 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1897 if (useChecksum) {
1898 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1899 "gles1_decoder_context_t::decode, OP_glGetTexParameteriv: GL checksumCalculator failure\n");
1900 }
1901 size_t totalTmpSize = size_params;
1902 totalTmpSize += checksumSize;
1903 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1904 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1905 #ifdef CHECK_GL_ERRORS
1906 GLint err = this->glGetError();
1907 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameteriv\n", err);
1908 #endif
1909 DECODER_DEBUG_LOG("gles1(%p): glGetTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
1910 this->glGetTexParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
1911 outptr_params.flush();
1912 if (useChecksum) {
1913 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1914 }
1915 stream->flush();
1916 SET_LASTCALL("glGetTexParameteriv");
1917 android::base::endTrace();
1918 break;
1919 }
1920 case OP_glGetTexParameterxv: {
1921 android::base::beginTrace("glGetTexParameterxv decode");
1922 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1923 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1924 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1925 if (useChecksum) {
1926 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1927 "gles1_decoder_context_t::decode, OP_glGetTexParameterxv: GL checksumCalculator failure\n");
1928 }
1929 size_t totalTmpSize = size_params;
1930 totalTmpSize += checksumSize;
1931 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1932 OutputBuffer outptr_params(&tmpBuf[0], size_params);
1933 #ifdef CHECK_GL_ERRORS
1934 GLint err = this->glGetError();
1935 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterxv\n", err);
1936 #endif
1937 DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1938 this->glGetTexParameterxv(var_target, var_pname, (GLfixed*)(outptr_params.get()));
1939 outptr_params.flush();
1940 if (useChecksum) {
1941 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1942 }
1943 stream->flush();
1944 SET_LASTCALL("glGetTexParameterxv");
1945 android::base::endTrace();
1946 break;
1947 }
1948 case OP_glHint: {
1949 android::base::beginTrace("glHint decode");
1950 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1951 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1952 if (useChecksum) {
1953 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1954 "gles1_decoder_context_t::decode, OP_glHint: GL checksumCalculator failure\n");
1955 }
1956 #ifdef CHECK_GL_ERRORS
1957 GLint err = this->glGetError();
1958 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glHint\n", err);
1959 #endif
1960 DECODER_DEBUG_LOG("gles1(%p): glHint(target:0x%08x mode:0x%08x )", stream, var_target, var_mode);
1961 this->glHint(var_target, var_mode);
1962 SET_LASTCALL("glHint");
1963 android::base::endTrace();
1964 break;
1965 }
1966 case OP_glIsBuffer: {
1967 android::base::beginTrace("glIsBuffer decode");
1968 GLuint var_buffer = Unpack<GLuint,uint32_t>(ptr + 8);
1969 if (useChecksum) {
1970 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1971 "gles1_decoder_context_t::decode, OP_glIsBuffer: GL checksumCalculator failure\n");
1972 }
1973 size_t totalTmpSize = sizeof(GLboolean);
1974 totalTmpSize += checksumSize;
1975 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1976 #ifdef CHECK_GL_ERRORS
1977 GLint err = this->glGetError();
1978 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsBuffer\n", err);
1979 #endif
1980 DECODER_DEBUG_LOG("gles1(%p): glIsBuffer(buffer:%u )", stream, var_buffer);
1981 *(GLboolean *)(&tmpBuf[0]) = this->glIsBuffer(var_buffer);
1982 if (useChecksum) {
1983 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1984 }
1985 stream->flush();
1986 SET_LASTCALL("glIsBuffer");
1987 android::base::endTrace();
1988 break;
1989 }
1990 case OP_glIsEnabled: {
1991 android::base::beginTrace("glIsEnabled decode");
1992 GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
1993 if (useChecksum) {
1994 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1995 "gles1_decoder_context_t::decode, OP_glIsEnabled: GL checksumCalculator failure\n");
1996 }
1997 size_t totalTmpSize = sizeof(GLboolean);
1998 totalTmpSize += checksumSize;
1999 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
2000 #ifdef CHECK_GL_ERRORS
2001 GLint err = this->glGetError();
2002 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsEnabled\n", err);
2003 #endif
2004 DECODER_DEBUG_LOG("gles1(%p): glIsEnabled(cap:0x%08x )", stream, var_cap);
2005 *(GLboolean *)(&tmpBuf[0]) = this->glIsEnabled(var_cap);
2006 if (useChecksum) {
2007 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
2008 }
2009 stream->flush();
2010 SET_LASTCALL("glIsEnabled");
2011 android::base::endTrace();
2012 break;
2013 }
2014 case OP_glIsTexture: {
2015 android::base::beginTrace("glIsTexture decode");
2016 GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8);
2017 if (useChecksum) {
2018 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2019 "gles1_decoder_context_t::decode, OP_glIsTexture: GL checksumCalculator failure\n");
2020 }
2021 size_t totalTmpSize = sizeof(GLboolean);
2022 totalTmpSize += checksumSize;
2023 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
2024 #ifdef CHECK_GL_ERRORS
2025 GLint err = this->glGetError();
2026 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsTexture\n", err);
2027 #endif
2028 DECODER_DEBUG_LOG("gles1(%p): glIsTexture(texture:%u )", stream, var_texture);
2029 *(GLboolean *)(&tmpBuf[0]) = this->glIsTexture(var_texture);
2030 if (useChecksum) {
2031 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
2032 }
2033 stream->flush();
2034 SET_LASTCALL("glIsTexture");
2035 android::base::endTrace();
2036 break;
2037 }
2038 case OP_glLightModelx: {
2039 android::base::beginTrace("glLightModelx decode");
2040 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2041 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2042 if (useChecksum) {
2043 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2044 "gles1_decoder_context_t::decode, OP_glLightModelx: GL checksumCalculator failure\n");
2045 }
2046 #ifdef CHECK_GL_ERRORS
2047 GLint err = this->glGetError();
2048 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelx\n", err);
2049 #endif
2050 DECODER_DEBUG_LOG("gles1(%p): glLightModelx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
2051 this->glLightModelx(var_pname, var_param);
2052 SET_LASTCALL("glLightModelx");
2053 android::base::endTrace();
2054 break;
2055 }
2056 case OP_glLightModelxv: {
2057 android::base::beginTrace("glLightModelxv decode");
2058 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2059 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
2060 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
2061 if (useChecksum) {
2062 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
2063 "gles1_decoder_context_t::decode, OP_glLightModelxv: GL checksumCalculator failure\n");
2064 }
2065 #ifdef CHECK_GL_ERRORS
2066 GLint err = this->glGetError();
2067 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxv\n", err);
2068 #endif
2069 DECODER_DEBUG_LOG("gles1(%p): glLightModelxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2070 this->glLightModelxv(var_pname, (const GLfixed*)(inptr_params.get()));
2071 SET_LASTCALL("glLightModelxv");
2072 android::base::endTrace();
2073 break;
2074 }
2075 case OP_glLightx: {
2076 android::base::beginTrace("glLightx decode");
2077 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
2078 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2079 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2080 if (useChecksum) {
2081 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2082 "gles1_decoder_context_t::decode, OP_glLightx: GL checksumCalculator failure\n");
2083 }
2084 #ifdef CHECK_GL_ERRORS
2085 GLint err = this->glGetError();
2086 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightx\n", err);
2087 #endif
2088 DECODER_DEBUG_LOG("gles1(%p): glLightx(light:0x%08x pname:0x%08x param:0x%08x )", stream, var_light, var_pname, var_param);
2089 this->glLightx(var_light, var_pname, var_param);
2090 SET_LASTCALL("glLightx");
2091 android::base::endTrace();
2092 break;
2093 }
2094 case OP_glLightxv: {
2095 android::base::beginTrace("glLightxv decode");
2096 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
2097 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2098 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2099 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2100 if (useChecksum) {
2101 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2102 "gles1_decoder_context_t::decode, OP_glLightxv: GL checksumCalculator failure\n");
2103 }
2104 #ifdef CHECK_GL_ERRORS
2105 GLint err = this->glGetError();
2106 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxv\n", err);
2107 #endif
2108 DECODER_DEBUG_LOG("gles1(%p): glLightxv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2109 this->glLightxv(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
2110 SET_LASTCALL("glLightxv");
2111 android::base::endTrace();
2112 break;
2113 }
2114 case OP_glLineWidthx: {
2115 android::base::beginTrace("glLineWidthx decode");
2116 GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8);
2117 if (useChecksum) {
2118 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2119 "gles1_decoder_context_t::decode, OP_glLineWidthx: GL checksumCalculator failure\n");
2120 }
2121 #ifdef CHECK_GL_ERRORS
2122 GLint err = this->glGetError();
2123 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidthx\n", err);
2124 #endif
2125 DECODER_DEBUG_LOG("gles1(%p): glLineWidthx(width:0x%08x )", stream, var_width);
2126 this->glLineWidthx(var_width);
2127 SET_LASTCALL("glLineWidthx");
2128 android::base::endTrace();
2129 break;
2130 }
2131 case OP_glLoadIdentity: {
2132 android::base::beginTrace("glLoadIdentity decode");
2133 if (useChecksum) {
2134 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
2135 "gles1_decoder_context_t::decode, OP_glLoadIdentity: GL checksumCalculator failure\n");
2136 }
2137 #ifdef CHECK_GL_ERRORS
2138 GLint err = this->glGetError();
2139 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadIdentity\n", err);
2140 #endif
2141 DECODER_DEBUG_LOG("gles1(%p): glLoadIdentity()", stream);
2142 this->glLoadIdentity();
2143 SET_LASTCALL("glLoadIdentity");
2144 android::base::endTrace();
2145 break;
2146 }
2147 case OP_glLoadMatrixx: {
2148 android::base::beginTrace("glLoadMatrixx decode");
2149 uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
2150 InputBuffer inptr_m(ptr + 8 + 4, size_m);
2151 if (useChecksum) {
2152 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
2153 "gles1_decoder_context_t::decode, OP_glLoadMatrixx: GL checksumCalculator failure\n");
2154 }
2155 #ifdef CHECK_GL_ERRORS
2156 GLint err = this->glGetError();
2157 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixx\n", err);
2158 #endif
2159 DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixx(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
2160 this->glLoadMatrixx((const GLfixed*)(inptr_m.get()));
2161 SET_LASTCALL("glLoadMatrixx");
2162 android::base::endTrace();
2163 break;
2164 }
2165 case OP_glLogicOp: {
2166 android::base::beginTrace("glLogicOp decode");
2167 GLenum var_opcode = Unpack<GLenum,uint32_t>(ptr + 8);
2168 if (useChecksum) {
2169 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2170 "gles1_decoder_context_t::decode, OP_glLogicOp: GL checksumCalculator failure\n");
2171 }
2172 #ifdef CHECK_GL_ERRORS
2173 GLint err = this->glGetError();
2174 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLogicOp\n", err);
2175 #endif
2176 DECODER_DEBUG_LOG("gles1(%p): glLogicOp(opcode:0x%08x )", stream, var_opcode);
2177 this->glLogicOp(var_opcode);
2178 SET_LASTCALL("glLogicOp");
2179 android::base::endTrace();
2180 break;
2181 }
2182 case OP_glMaterialx: {
2183 android::base::beginTrace("glMaterialx decode");
2184 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
2185 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2186 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2187 if (useChecksum) {
2188 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2189 "gles1_decoder_context_t::decode, OP_glMaterialx: GL checksumCalculator failure\n");
2190 }
2191 #ifdef CHECK_GL_ERRORS
2192 GLint err = this->glGetError();
2193 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialx\n", err);
2194 #endif
2195 DECODER_DEBUG_LOG("gles1(%p): glMaterialx(face:0x%08x pname:0x%08x param:0x%08x )", stream, var_face, var_pname, var_param);
2196 this->glMaterialx(var_face, var_pname, var_param);
2197 SET_LASTCALL("glMaterialx");
2198 android::base::endTrace();
2199 break;
2200 }
2201 case OP_glMaterialxv: {
2202 android::base::beginTrace("glMaterialxv decode");
2203 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
2204 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2205 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2206 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2207 if (useChecksum) {
2208 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2209 "gles1_decoder_context_t::decode, OP_glMaterialxv: GL checksumCalculator failure\n");
2210 }
2211 #ifdef CHECK_GL_ERRORS
2212 GLint err = this->glGetError();
2213 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxv\n", err);
2214 #endif
2215 DECODER_DEBUG_LOG("gles1(%p): glMaterialxv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2216 this->glMaterialxv(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
2217 SET_LASTCALL("glMaterialxv");
2218 android::base::endTrace();
2219 break;
2220 }
2221 case OP_glMatrixMode: {
2222 android::base::beginTrace("glMatrixMode decode");
2223 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
2224 if (useChecksum) {
2225 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2226 "gles1_decoder_context_t::decode, OP_glMatrixMode: GL checksumCalculator failure\n");
2227 }
2228 #ifdef CHECK_GL_ERRORS
2229 GLint err = this->glGetError();
2230 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixMode\n", err);
2231 #endif
2232 DECODER_DEBUG_LOG("gles1(%p): glMatrixMode(mode:0x%08x )", stream, var_mode);
2233 this->glMatrixMode(var_mode);
2234 SET_LASTCALL("glMatrixMode");
2235 android::base::endTrace();
2236 break;
2237 }
2238 case OP_glMultMatrixx: {
2239 android::base::beginTrace("glMultMatrixx decode");
2240 uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
2241 InputBuffer inptr_m(ptr + 8 + 4, size_m);
2242 if (useChecksum) {
2243 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
2244 "gles1_decoder_context_t::decode, OP_glMultMatrixx: GL checksumCalculator failure\n");
2245 }
2246 #ifdef CHECK_GL_ERRORS
2247 GLint err = this->glGetError();
2248 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixx\n", err);
2249 #endif
2250 DECODER_DEBUG_LOG("gles1(%p): glMultMatrixx(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
2251 this->glMultMatrixx((const GLfixed*)(inptr_m.get()));
2252 SET_LASTCALL("glMultMatrixx");
2253 android::base::endTrace();
2254 break;
2255 }
2256 case OP_glMultiTexCoord4x: {
2257 android::base::beginTrace("glMultiTexCoord4x decode");
2258 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2259 GLfixed var_s = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2260 GLfixed var_t = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2261 GLfixed var_r = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
2262 GLfixed var_q = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2263 if (useChecksum) {
2264 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
2265 "gles1_decoder_context_t::decode, OP_glMultiTexCoord4x: GL checksumCalculator failure\n");
2266 }
2267 #ifdef CHECK_GL_ERRORS
2268 GLint err = this->glGetError();
2269 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4x\n", err);
2270 #endif
2271 DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4x(target:0x%08x s:0x%08x t:0x%08x r:0x%08x q:0x%08x )", stream, var_target, var_s, var_t, var_r, var_q);
2272 this->glMultiTexCoord4x(var_target, var_s, var_t, var_r, var_q);
2273 SET_LASTCALL("glMultiTexCoord4x");
2274 android::base::endTrace();
2275 break;
2276 }
2277 case OP_glNormal3x: {
2278 android::base::beginTrace("glNormal3x decode");
2279 GLfixed var_nx = Unpack<GLfixed,uint32_t>(ptr + 8);
2280 GLfixed var_ny = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2281 GLfixed var_nz = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2282 if (useChecksum) {
2283 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2284 "gles1_decoder_context_t::decode, OP_glNormal3x: GL checksumCalculator failure\n");
2285 }
2286 #ifdef CHECK_GL_ERRORS
2287 GLint err = this->glGetError();
2288 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3x\n", err);
2289 #endif
2290 DECODER_DEBUG_LOG("gles1(%p): glNormal3x(nx:0x%08x ny:0x%08x nz:0x%08x )", stream, var_nx, var_ny, var_nz);
2291 this->glNormal3x(var_nx, var_ny, var_nz);
2292 SET_LASTCALL("glNormal3x");
2293 android::base::endTrace();
2294 break;
2295 }
2296 case OP_glNormalPointer: {
2297 android::base::beginTrace("glNormalPointer decode");
2298 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
2299 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
2300 uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2301 InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4, size_pointer);
2302 if (useChecksum) {
2303 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + size_pointer, checksumSize,
2304 "gles1_decoder_context_t::decode, OP_glNormalPointer: GL checksumCalculator failure\n");
2305 }
2306 #ifdef CHECK_GL_ERRORS
2307 GLint err = this->glGetError();
2308 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointer\n", err);
2309 #endif
2310 DECODER_DEBUG_LOG("gles1(%p): glNormalPointer(type:0x%08x stride:%d pointer:%p(%u) )", stream, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2311 this->glNormalPointer(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2312 SET_LASTCALL("glNormalPointer");
2313 android::base::endTrace();
2314 break;
2315 }
2316 case OP_glOrthox: {
2317 android::base::beginTrace("glOrthox decode");
2318 GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
2319 GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2320 GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2321 GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
2322 GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2323 GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2324 if (useChecksum) {
2325 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
2326 "gles1_decoder_context_t::decode, OP_glOrthox: GL checksumCalculator failure\n");
2327 }
2328 #ifdef CHECK_GL_ERRORS
2329 GLint err = this->glGetError();
2330 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthox\n", err);
2331 #endif
2332 DECODER_DEBUG_LOG("gles1(%p): glOrthox(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
2333 this->glOrthox(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
2334 SET_LASTCALL("glOrthox");
2335 android::base::endTrace();
2336 break;
2337 }
2338 case OP_glPixelStorei: {
2339 android::base::beginTrace("glPixelStorei decode");
2340 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2341 GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2342 if (useChecksum) {
2343 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2344 "gles1_decoder_context_t::decode, OP_glPixelStorei: GL checksumCalculator failure\n");
2345 }
2346 #ifdef CHECK_GL_ERRORS
2347 GLint err = this->glGetError();
2348 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPixelStorei\n", err);
2349 #endif
2350 DECODER_DEBUG_LOG("gles1(%p): glPixelStorei(pname:0x%08x param:%d )", stream, var_pname, var_param);
2351 this->glPixelStorei(var_pname, var_param);
2352 SET_LASTCALL("glPixelStorei");
2353 android::base::endTrace();
2354 break;
2355 }
2356 case OP_glPointParameterx: {
2357 android::base::beginTrace("glPointParameterx decode");
2358 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2359 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2360 if (useChecksum) {
2361 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2362 "gles1_decoder_context_t::decode, OP_glPointParameterx: GL checksumCalculator failure\n");
2363 }
2364 #ifdef CHECK_GL_ERRORS
2365 GLint err = this->glGetError();
2366 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterx\n", err);
2367 #endif
2368 DECODER_DEBUG_LOG("gles1(%p): glPointParameterx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
2369 this->glPointParameterx(var_pname, var_param);
2370 SET_LASTCALL("glPointParameterx");
2371 android::base::endTrace();
2372 break;
2373 }
2374 case OP_glPointParameterxv: {
2375 android::base::beginTrace("glPointParameterxv decode");
2376 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2377 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
2378 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
2379 if (useChecksum) {
2380 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
2381 "gles1_decoder_context_t::decode, OP_glPointParameterxv: GL checksumCalculator failure\n");
2382 }
2383 #ifdef CHECK_GL_ERRORS
2384 GLint err = this->glGetError();
2385 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxv\n", err);
2386 #endif
2387 DECODER_DEBUG_LOG("gles1(%p): glPointParameterxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2388 this->glPointParameterxv(var_pname, (const GLfixed*)(inptr_params.get()));
2389 SET_LASTCALL("glPointParameterxv");
2390 android::base::endTrace();
2391 break;
2392 }
2393 case OP_glPointSizex: {
2394 android::base::beginTrace("glPointSizex decode");
2395 GLfixed var_size = Unpack<GLfixed,uint32_t>(ptr + 8);
2396 if (useChecksum) {
2397 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2398 "gles1_decoder_context_t::decode, OP_glPointSizex: GL checksumCalculator failure\n");
2399 }
2400 #ifdef CHECK_GL_ERRORS
2401 GLint err = this->glGetError();
2402 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizex\n", err);
2403 #endif
2404 DECODER_DEBUG_LOG("gles1(%p): glPointSizex(size:0x%08x )", stream, var_size);
2405 this->glPointSizex(var_size);
2406 SET_LASTCALL("glPointSizex");
2407 android::base::endTrace();
2408 break;
2409 }
2410 case OP_glPolygonOffsetx: {
2411 android::base::beginTrace("glPolygonOffsetx decode");
2412 GLfixed var_factor = Unpack<GLfixed,uint32_t>(ptr + 8);
2413 GLfixed var_units = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2414 if (useChecksum) {
2415 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2416 "gles1_decoder_context_t::decode, OP_glPolygonOffsetx: GL checksumCalculator failure\n");
2417 }
2418 #ifdef CHECK_GL_ERRORS
2419 GLint err = this->glGetError();
2420 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffsetx\n", err);
2421 #endif
2422 DECODER_DEBUG_LOG("gles1(%p): glPolygonOffsetx(factor:0x%08x units:0x%08x )", stream, var_factor, var_units);
2423 this->glPolygonOffsetx(var_factor, var_units);
2424 SET_LASTCALL("glPolygonOffsetx");
2425 android::base::endTrace();
2426 break;
2427 }
2428 case OP_glPopMatrix: {
2429 android::base::beginTrace("glPopMatrix decode");
2430 if (useChecksum) {
2431 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
2432 "gles1_decoder_context_t::decode, OP_glPopMatrix: GL checksumCalculator failure\n");
2433 }
2434 #ifdef CHECK_GL_ERRORS
2435 GLint err = this->glGetError();
2436 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPopMatrix\n", err);
2437 #endif
2438 DECODER_DEBUG_LOG("gles1(%p): glPopMatrix()", stream);
2439 this->glPopMatrix();
2440 SET_LASTCALL("glPopMatrix");
2441 android::base::endTrace();
2442 break;
2443 }
2444 case OP_glPushMatrix: {
2445 android::base::beginTrace("glPushMatrix decode");
2446 if (useChecksum) {
2447 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
2448 "gles1_decoder_context_t::decode, OP_glPushMatrix: GL checksumCalculator failure\n");
2449 }
2450 #ifdef CHECK_GL_ERRORS
2451 GLint err = this->glGetError();
2452 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPushMatrix\n", err);
2453 #endif
2454 DECODER_DEBUG_LOG("gles1(%p): glPushMatrix()", stream);
2455 this->glPushMatrix();
2456 SET_LASTCALL("glPushMatrix");
2457 android::base::endTrace();
2458 break;
2459 }
2460 case OP_glReadPixels: {
2461 android::base::beginTrace("glReadPixels decode");
2462 GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
2463 GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2464 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2465 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2466 GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2467 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2468 uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
2469 if (useChecksum) {
2470 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
2471 "gles1_decoder_context_t::decode, OP_glReadPixels: GL checksumCalculator failure\n");
2472 }
2473 size_t totalTmpSize = size_pixels;
2474 totalTmpSize += checksumSize;
2475 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
2476 OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels);
2477 #ifdef CHECK_GL_ERRORS
2478 GLint err = this->glGetError();
2479 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glReadPixels\n", err);
2480 #endif
2481 DECODER_DEBUG_LOG("gles1(%p): glReadPixels(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()), size_pixels);
2482 this->glReadPixels(var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()));
2483 outptr_pixels.flush();
2484 if (useChecksum) {
2485 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
2486 }
2487 stream->flush();
2488 SET_LASTCALL("glReadPixels");
2489 android::base::endTrace();
2490 break;
2491 }
2492 case OP_glRotatex: {
2493 android::base::beginTrace("glRotatex decode");
2494 GLfixed var_angle = Unpack<GLfixed,uint32_t>(ptr + 8);
2495 GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2496 GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2497 GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
2498 if (useChecksum) {
2499 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2500 "gles1_decoder_context_t::decode, OP_glRotatex: GL checksumCalculator failure\n");
2501 }
2502 #ifdef CHECK_GL_ERRORS
2503 GLint err = this->glGetError();
2504 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatex\n", err);
2505 #endif
2506 DECODER_DEBUG_LOG("gles1(%p): glRotatex(angle:0x%08x x:0x%08x y:0x%08x z:0x%08x )", stream, var_angle, var_x, var_y, var_z);
2507 this->glRotatex(var_angle, var_x, var_y, var_z);
2508 SET_LASTCALL("glRotatex");
2509 android::base::endTrace();
2510 break;
2511 }
2512 case OP_glSampleCoverage: {
2513 android::base::beginTrace("glSampleCoverage decode");
2514 GLclampf var_value = Unpack<GLclampf,uint32_t>(ptr + 8);
2515 GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
2516 if (useChecksum) {
2517 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
2518 "gles1_decoder_context_t::decode, OP_glSampleCoverage: GL checksumCalculator failure\n");
2519 }
2520 #ifdef CHECK_GL_ERRORS
2521 GLint err = this->glGetError();
2522 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoverage\n", err);
2523 #endif
2524 DECODER_DEBUG_LOG("gles1(%p): glSampleCoverage(value:%f invert:%d )", stream, var_value, var_invert);
2525 this->glSampleCoverage(var_value, var_invert);
2526 SET_LASTCALL("glSampleCoverage");
2527 android::base::endTrace();
2528 break;
2529 }
2530 case OP_glSampleCoveragex: {
2531 android::base::beginTrace("glSampleCoveragex decode");
2532 GLclampx var_value = Unpack<GLclampx,uint32_t>(ptr + 8);
2533 GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
2534 if (useChecksum) {
2535 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
2536 "gles1_decoder_context_t::decode, OP_glSampleCoveragex: GL checksumCalculator failure\n");
2537 }
2538 #ifdef CHECK_GL_ERRORS
2539 GLint err = this->glGetError();
2540 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoveragex\n", err);
2541 #endif
2542 DECODER_DEBUG_LOG("gles1(%p): glSampleCoveragex(value:0x%08x invert:%d )", stream, var_value, var_invert);
2543 this->glSampleCoveragex(var_value, var_invert);
2544 SET_LASTCALL("glSampleCoveragex");
2545 android::base::endTrace();
2546 break;
2547 }
2548 case OP_glScalex: {
2549 android::base::beginTrace("glScalex decode");
2550 GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
2551 GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2552 GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2553 if (useChecksum) {
2554 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2555 "gles1_decoder_context_t::decode, OP_glScalex: GL checksumCalculator failure\n");
2556 }
2557 #ifdef CHECK_GL_ERRORS
2558 GLint err = this->glGetError();
2559 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalex\n", err);
2560 #endif
2561 DECODER_DEBUG_LOG("gles1(%p): glScalex(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
2562 this->glScalex(var_x, var_y, var_z);
2563 SET_LASTCALL("glScalex");
2564 android::base::endTrace();
2565 break;
2566 }
2567 case OP_glScissor: {
2568 android::base::beginTrace("glScissor decode");
2569 GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
2570 GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2571 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2572 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2573 if (useChecksum) {
2574 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2575 "gles1_decoder_context_t::decode, OP_glScissor: GL checksumCalculator failure\n");
2576 }
2577 #ifdef CHECK_GL_ERRORS
2578 GLint err = this->glGetError();
2579 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScissor\n", err);
2580 #endif
2581 DECODER_DEBUG_LOG("gles1(%p): glScissor(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
2582 this->glScissor(var_x, var_y, var_width, var_height);
2583 SET_LASTCALL("glScissor");
2584 android::base::endTrace();
2585 break;
2586 }
2587 case OP_glShadeModel: {
2588 android::base::beginTrace("glShadeModel decode");
2589 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
2590 if (useChecksum) {
2591 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2592 "gles1_decoder_context_t::decode, OP_glShadeModel: GL checksumCalculator failure\n");
2593 }
2594 #ifdef CHECK_GL_ERRORS
2595 GLint err = this->glGetError();
2596 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glShadeModel\n", err);
2597 #endif
2598 DECODER_DEBUG_LOG("gles1(%p): glShadeModel(mode:0x%08x )", stream, var_mode);
2599 this->glShadeModel(var_mode);
2600 SET_LASTCALL("glShadeModel");
2601 android::base::endTrace();
2602 break;
2603 }
2604 case OP_glStencilFunc: {
2605 android::base::beginTrace("glStencilFunc decode");
2606 GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
2607 GLint var_ref = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2608 GLuint var_mask = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
2609 if (useChecksum) {
2610 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2611 "gles1_decoder_context_t::decode, OP_glStencilFunc: GL checksumCalculator failure\n");
2612 }
2613 #ifdef CHECK_GL_ERRORS
2614 GLint err = this->glGetError();
2615 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilFunc\n", err);
2616 #endif
2617 DECODER_DEBUG_LOG("gles1(%p): glStencilFunc(func:0x%08x ref:%d mask:%u )", stream, var_func, var_ref, var_mask);
2618 this->glStencilFunc(var_func, var_ref, var_mask);
2619 SET_LASTCALL("glStencilFunc");
2620 android::base::endTrace();
2621 break;
2622 }
2623 case OP_glStencilMask: {
2624 android::base::beginTrace("glStencilMask decode");
2625 GLuint var_mask = Unpack<GLuint,uint32_t>(ptr + 8);
2626 if (useChecksum) {
2627 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2628 "gles1_decoder_context_t::decode, OP_glStencilMask: GL checksumCalculator failure\n");
2629 }
2630 #ifdef CHECK_GL_ERRORS
2631 GLint err = this->glGetError();
2632 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilMask\n", err);
2633 #endif
2634 DECODER_DEBUG_LOG("gles1(%p): glStencilMask(mask:%u )", stream, var_mask);
2635 this->glStencilMask(var_mask);
2636 SET_LASTCALL("glStencilMask");
2637 android::base::endTrace();
2638 break;
2639 }
2640 case OP_glStencilOp: {
2641 android::base::beginTrace("glStencilOp decode");
2642 GLenum var_fail = Unpack<GLenum,uint32_t>(ptr + 8);
2643 GLenum var_zfail = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2644 GLenum var_zpass = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
2645 if (useChecksum) {
2646 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2647 "gles1_decoder_context_t::decode, OP_glStencilOp: GL checksumCalculator failure\n");
2648 }
2649 #ifdef CHECK_GL_ERRORS
2650 GLint err = this->glGetError();
2651 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilOp\n", err);
2652 #endif
2653 DECODER_DEBUG_LOG("gles1(%p): glStencilOp(fail:0x%08x zfail:0x%08x zpass:0x%08x )", stream, var_fail, var_zfail, var_zpass);
2654 this->glStencilOp(var_fail, var_zfail, var_zpass);
2655 SET_LASTCALL("glStencilOp");
2656 android::base::endTrace();
2657 break;
2658 }
2659 case OP_glTexCoordPointer: {
2660 android::base::beginTrace("glTexCoordPointer decode");
2661 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2662 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2663 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2664 uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
2665 InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
2666 if (useChecksum) {
2667 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
2668 "gles1_decoder_context_t::decode, OP_glTexCoordPointer: GL checksumCalculator failure\n");
2669 }
2670 #ifdef CHECK_GL_ERRORS
2671 GLint err = this->glGetError();
2672 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointer\n", err);
2673 #endif
2674 DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2675 this->glTexCoordPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2676 SET_LASTCALL("glTexCoordPointer");
2677 android::base::endTrace();
2678 break;
2679 }
2680 case OP_glTexEnvi: {
2681 android::base::beginTrace("glTexEnvi decode");
2682 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2683 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2684 GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2685 if (useChecksum) {
2686 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2687 "gles1_decoder_context_t::decode, OP_glTexEnvi: GL checksumCalculator failure\n");
2688 }
2689 #ifdef CHECK_GL_ERRORS
2690 GLint err = this->glGetError();
2691 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvi\n", err);
2692 #endif
2693 DECODER_DEBUG_LOG("gles1(%p): glTexEnvi(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
2694 this->glTexEnvi(var_target, var_pname, var_param);
2695 SET_LASTCALL("glTexEnvi");
2696 android::base::endTrace();
2697 break;
2698 }
2699 case OP_glTexEnvx: {
2700 android::base::beginTrace("glTexEnvx decode");
2701 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2702 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2703 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2704 if (useChecksum) {
2705 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2706 "gles1_decoder_context_t::decode, OP_glTexEnvx: GL checksumCalculator failure\n");
2707 }
2708 #ifdef CHECK_GL_ERRORS
2709 GLint err = this->glGetError();
2710 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvx\n", err);
2711 #endif
2712 DECODER_DEBUG_LOG("gles1(%p): glTexEnvx(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
2713 this->glTexEnvx(var_target, var_pname, var_param);
2714 SET_LASTCALL("glTexEnvx");
2715 android::base::endTrace();
2716 break;
2717 }
2718 case OP_glTexEnviv: {
2719 android::base::beginTrace("glTexEnviv decode");
2720 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2721 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2722 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2723 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2724 if (useChecksum) {
2725 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2726 "gles1_decoder_context_t::decode, OP_glTexEnviv: GL checksumCalculator failure\n");
2727 }
2728 #ifdef CHECK_GL_ERRORS
2729 GLint err = this->glGetError();
2730 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnviv\n", err);
2731 #endif
2732 DECODER_DEBUG_LOG("gles1(%p): glTexEnviv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLint*)(inptr_params.get()), size_params);
2733 this->glTexEnviv(var_target, var_pname, (const GLint*)(inptr_params.get()));
2734 SET_LASTCALL("glTexEnviv");
2735 android::base::endTrace();
2736 break;
2737 }
2738 case OP_glTexEnvxv: {
2739 android::base::beginTrace("glTexEnvxv decode");
2740 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2741 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2742 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2743 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2744 if (useChecksum) {
2745 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2746 "gles1_decoder_context_t::decode, OP_glTexEnvxv: GL checksumCalculator failure\n");
2747 }
2748 #ifdef CHECK_GL_ERRORS
2749 GLint err = this->glGetError();
2750 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxv\n", err);
2751 #endif
2752 DECODER_DEBUG_LOG("gles1(%p): glTexEnvxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2753 this->glTexEnvxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
2754 SET_LASTCALL("glTexEnvxv");
2755 android::base::endTrace();
2756 break;
2757 }
2758 case OP_glTexImage2D: {
2759 android::base::beginTrace("glTexImage2D decode");
2760 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2761 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2762 GLint var_internalformat = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2763 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2764 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2765 GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2766 GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
2767 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2768 uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2769 InputBuffer inptr_pixels(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_pixels);
2770 if (useChecksum) {
2771 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,
2772 "gles1_decoder_context_t::decode, OP_glTexImage2D: GL checksumCalculator failure\n");
2773 }
2774 #ifdef CHECK_GL_ERRORS
2775 GLint err = this->glGetError();
2776 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexImage2D\n", err);
2777 #endif
2778 DECODER_DEBUG_LOG("gles1(%p): glTexImage2D(target:0x%08x level:%d internalformat:%d width:%d height:%d border:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
2779 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()));
2780 SET_LASTCALL("glTexImage2D");
2781 android::base::endTrace();
2782 break;
2783 }
2784 case OP_glTexParameteri: {
2785 android::base::beginTrace("glTexParameteri decode");
2786 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2787 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2788 GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2789 if (useChecksum) {
2790 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2791 "gles1_decoder_context_t::decode, OP_glTexParameteri: GL checksumCalculator failure\n");
2792 }
2793 #ifdef CHECK_GL_ERRORS
2794 GLint err = this->glGetError();
2795 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameteri\n", err);
2796 #endif
2797 DECODER_DEBUG_LOG("gles1(%p): glTexParameteri(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
2798 this->glTexParameteri(var_target, var_pname, var_param);
2799 SET_LASTCALL("glTexParameteri");
2800 android::base::endTrace();
2801 break;
2802 }
2803 case OP_glTexParameterx: {
2804 android::base::beginTrace("glTexParameterx decode");
2805 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2806 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2807 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2808 if (useChecksum) {
2809 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2810 "gles1_decoder_context_t::decode, OP_glTexParameterx: GL checksumCalculator failure\n");
2811 }
2812 #ifdef CHECK_GL_ERRORS
2813 GLint err = this->glGetError();
2814 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterx\n", err);
2815 #endif
2816 DECODER_DEBUG_LOG("gles1(%p): glTexParameterx(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
2817 this->glTexParameterx(var_target, var_pname, var_param);
2818 SET_LASTCALL("glTexParameterx");
2819 android::base::endTrace();
2820 break;
2821 }
2822 case OP_glTexParameteriv: {
2823 android::base::beginTrace("glTexParameteriv decode");
2824 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2825 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2826 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2827 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2828 if (useChecksum) {
2829 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2830 "gles1_decoder_context_t::decode, OP_glTexParameteriv: GL checksumCalculator failure\n");
2831 }
2832 #ifdef CHECK_GL_ERRORS
2833 GLint err = this->glGetError();
2834 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameteriv\n", err);
2835 #endif
2836 DECODER_DEBUG_LOG("gles1(%p): glTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLint*)(inptr_params.get()), size_params);
2837 this->glTexParameteriv(var_target, var_pname, (const GLint*)(inptr_params.get()));
2838 SET_LASTCALL("glTexParameteriv");
2839 android::base::endTrace();
2840 break;
2841 }
2842 case OP_glTexParameterxv: {
2843 android::base::beginTrace("glTexParameterxv decode");
2844 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2845 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2846 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2847 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2848 if (useChecksum) {
2849 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2850 "gles1_decoder_context_t::decode, OP_glTexParameterxv: GL checksumCalculator failure\n");
2851 }
2852 #ifdef CHECK_GL_ERRORS
2853 GLint err = this->glGetError();
2854 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxv\n", err);
2855 #endif
2856 DECODER_DEBUG_LOG("gles1(%p): glTexParameterxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2857 this->glTexParameterxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
2858 SET_LASTCALL("glTexParameterxv");
2859 android::base::endTrace();
2860 break;
2861 }
2862 case OP_glTexSubImage2D: {
2863 android::base::beginTrace("glTexSubImage2D decode");
2864 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2865 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2866 GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2867 GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
2868 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2869 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2870 GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
2871 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2872 uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2873 InputBuffer inptr_pixels(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_pixels);
2874 if (useChecksum) {
2875 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,
2876 "gles1_decoder_context_t::decode, OP_glTexSubImage2D: GL checksumCalculator failure\n");
2877 }
2878 #ifdef CHECK_GL_ERRORS
2879 GLint err = this->glGetError();
2880 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexSubImage2D\n", err);
2881 #endif
2882 DECODER_DEBUG_LOG("gles1(%p): glTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
2883 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()));
2884 SET_LASTCALL("glTexSubImage2D");
2885 android::base::endTrace();
2886 break;
2887 }
2888 case OP_glTranslatex: {
2889 android::base::beginTrace("glTranslatex decode");
2890 GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
2891 GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2892 GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2893 if (useChecksum) {
2894 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2895 "gles1_decoder_context_t::decode, OP_glTranslatex: GL checksumCalculator failure\n");
2896 }
2897 #ifdef CHECK_GL_ERRORS
2898 GLint err = this->glGetError();
2899 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatex\n", err);
2900 #endif
2901 DECODER_DEBUG_LOG("gles1(%p): glTranslatex(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
2902 this->glTranslatex(var_x, var_y, var_z);
2903 SET_LASTCALL("glTranslatex");
2904 android::base::endTrace();
2905 break;
2906 }
2907 case OP_glVertexPointer: {
2908 android::base::beginTrace("glVertexPointer decode");
2909 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2910 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2911 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2912 uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
2913 InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
2914 if (useChecksum) {
2915 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
2916 "gles1_decoder_context_t::decode, OP_glVertexPointer: GL checksumCalculator failure\n");
2917 }
2918 #ifdef CHECK_GL_ERRORS
2919 GLint err = this->glGetError();
2920 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointer\n", err);
2921 #endif
2922 DECODER_DEBUG_LOG("gles1(%p): glVertexPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2923 this->glVertexPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2924 SET_LASTCALL("glVertexPointer");
2925 android::base::endTrace();
2926 break;
2927 }
2928 case OP_glViewport: {
2929 android::base::beginTrace("glViewport decode");
2930 GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
2931 GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2932 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2933 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2934 if (useChecksum) {
2935 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2936 "gles1_decoder_context_t::decode, OP_glViewport: GL checksumCalculator failure\n");
2937 }
2938 #ifdef CHECK_GL_ERRORS
2939 GLint err = this->glGetError();
2940 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glViewport\n", err);
2941 #endif
2942 DECODER_DEBUG_LOG("gles1(%p): glViewport(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
2943 this->glViewport(var_x, var_y, var_width, var_height);
2944 SET_LASTCALL("glViewport");
2945 android::base::endTrace();
2946 break;
2947 }
2948 case OP_glPointSizePointerOES: {
2949 android::base::beginTrace("glPointSizePointerOES decode");
2950 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
2951 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
2952 uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2953 InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4, size_pointer);
2954 if (useChecksum) {
2955 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + size_pointer, checksumSize,
2956 "gles1_decoder_context_t::decode, OP_glPointSizePointerOES: GL checksumCalculator failure\n");
2957 }
2958 #ifdef CHECK_GL_ERRORS
2959 GLint err = this->glGetError();
2960 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerOES\n", err);
2961 #endif
2962 DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerOES(type:0x%08x stride:%d pointer:%p(%u) )", stream, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2963 this->glPointSizePointerOES(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2964 SET_LASTCALL("glPointSizePointerOES");
2965 android::base::endTrace();
2966 break;
2967 }
2968 case OP_glVertexPointerOffset: {
2969 android::base::beginTrace("glVertexPointerOffset decode");
2970 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2971 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2972 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2973 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
2974 if (useChecksum) {
2975 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2976 "gles1_decoder_context_t::decode, OP_glVertexPointerOffset: GL checksumCalculator failure\n");
2977 }
2978 #ifdef CHECK_GL_ERRORS
2979 GLint err = this->glGetError();
2980 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointerOffset\n", err);
2981 #endif
2982 DECODER_DEBUG_LOG("gles1(%p): glVertexPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
2983 this->glVertexPointerOffset(this, var_size, var_type, var_stride, var_offset);
2984 SET_LASTCALL("glVertexPointerOffset");
2985 android::base::endTrace();
2986 break;
2987 }
2988 case OP_glColorPointerOffset: {
2989 android::base::beginTrace("glColorPointerOffset decode");
2990 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2991 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2992 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2993 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
2994 if (useChecksum) {
2995 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2996 "gles1_decoder_context_t::decode, OP_glColorPointerOffset: GL checksumCalculator failure\n");
2997 }
2998 #ifdef CHECK_GL_ERRORS
2999 GLint err = this->glGetError();
3000 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointerOffset\n", err);
3001 #endif
3002 DECODER_DEBUG_LOG("gles1(%p): glColorPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3003 this->glColorPointerOffset(this, var_size, var_type, var_stride, var_offset);
3004 SET_LASTCALL("glColorPointerOffset");
3005 android::base::endTrace();
3006 break;
3007 }
3008 case OP_glNormalPointerOffset: {
3009 android::base::beginTrace("glNormalPointerOffset decode");
3010 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3011 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3012 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
3013 if (useChecksum) {
3014 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3015 "gles1_decoder_context_t::decode, OP_glNormalPointerOffset: GL checksumCalculator failure\n");
3016 }
3017 #ifdef CHECK_GL_ERRORS
3018 GLint err = this->glGetError();
3019 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointerOffset\n", err);
3020 #endif
3021 DECODER_DEBUG_LOG("gles1(%p): glNormalPointerOffset(type:0x%08x stride:%d offset:%u )", stream, var_type, var_stride, var_offset);
3022 this->glNormalPointerOffset(this, var_type, var_stride, var_offset);
3023 SET_LASTCALL("glNormalPointerOffset");
3024 android::base::endTrace();
3025 break;
3026 }
3027 case OP_glPointSizePointerOffset: {
3028 android::base::beginTrace("glPointSizePointerOffset decode");
3029 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3030 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3031 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
3032 if (useChecksum) {
3033 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3034 "gles1_decoder_context_t::decode, OP_glPointSizePointerOffset: GL checksumCalculator failure\n");
3035 }
3036 #ifdef CHECK_GL_ERRORS
3037 GLint err = this->glGetError();
3038 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerOffset\n", err);
3039 #endif
3040 DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerOffset(type:0x%08x stride:%d offset:%u )", stream, var_type, var_stride, var_offset);
3041 this->glPointSizePointerOffset(this, var_type, var_stride, var_offset);
3042 SET_LASTCALL("glPointSizePointerOffset");
3043 android::base::endTrace();
3044 break;
3045 }
3046 case OP_glTexCoordPointerOffset: {
3047 android::base::beginTrace("glTexCoordPointerOffset decode");
3048 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3049 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3050 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3051 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3052 if (useChecksum) {
3053 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3054 "gles1_decoder_context_t::decode, OP_glTexCoordPointerOffset: GL checksumCalculator failure\n");
3055 }
3056 #ifdef CHECK_GL_ERRORS
3057 GLint err = this->glGetError();
3058 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointerOffset\n", err);
3059 #endif
3060 DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3061 this->glTexCoordPointerOffset(this, var_size, var_type, var_stride, var_offset);
3062 SET_LASTCALL("glTexCoordPointerOffset");
3063 android::base::endTrace();
3064 break;
3065 }
3066 case OP_glWeightPointerOffset: {
3067 android::base::beginTrace("glWeightPointerOffset decode");
3068 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3069 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3070 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3071 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3072 if (useChecksum) {
3073 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3074 "gles1_decoder_context_t::decode, OP_glWeightPointerOffset: GL checksumCalculator failure\n");
3075 }
3076 #ifdef CHECK_GL_ERRORS
3077 GLint err = this->glGetError();
3078 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerOffset\n", err);
3079 #endif
3080 DECODER_DEBUG_LOG("gles1(%p): glWeightPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3081 this->glWeightPointerOffset(this, var_size, var_type, var_stride, var_offset);
3082 SET_LASTCALL("glWeightPointerOffset");
3083 android::base::endTrace();
3084 break;
3085 }
3086 case OP_glMatrixIndexPointerOffset: {
3087 android::base::beginTrace("glMatrixIndexPointerOffset decode");
3088 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3089 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3090 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3091 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3092 if (useChecksum) {
3093 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3094 "gles1_decoder_context_t::decode, OP_glMatrixIndexPointerOffset: GL checksumCalculator failure\n");
3095 }
3096 #ifdef CHECK_GL_ERRORS
3097 GLint err = this->glGetError();
3098 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerOffset\n", err);
3099 #endif
3100 DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3101 this->glMatrixIndexPointerOffset(this, var_size, var_type, var_stride, var_offset);
3102 SET_LASTCALL("glMatrixIndexPointerOffset");
3103 android::base::endTrace();
3104 break;
3105 }
3106 case OP_glVertexPointerData: {
3107 android::base::beginTrace("glVertexPointerData decode");
3108 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3109 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3110 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3111 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3112 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3113 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3114 if (useChecksum) {
3115 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3116 "gles1_decoder_context_t::decode, OP_glVertexPointerData: GL checksumCalculator failure\n");
3117 }
3118 #ifdef CHECK_GL_ERRORS
3119 GLint err = this->glGetError();
3120 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointerData\n", err);
3121 #endif
3122 DECODER_DEBUG_LOG("gles1(%p): glVertexPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3123 this->glVertexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3124 SET_LASTCALL("glVertexPointerData");
3125 android::base::endTrace();
3126 break;
3127 }
3128 case OP_glColorPointerData: {
3129 android::base::beginTrace("glColorPointerData decode");
3130 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3131 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3132 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3133 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3134 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3135 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3136 if (useChecksum) {
3137 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3138 "gles1_decoder_context_t::decode, OP_glColorPointerData: GL checksumCalculator failure\n");
3139 }
3140 #ifdef CHECK_GL_ERRORS
3141 GLint err = this->glGetError();
3142 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointerData\n", err);
3143 #endif
3144 DECODER_DEBUG_LOG("gles1(%p): glColorPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3145 this->glColorPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3146 SET_LASTCALL("glColorPointerData");
3147 android::base::endTrace();
3148 break;
3149 }
3150 case OP_glNormalPointerData: {
3151 android::base::beginTrace("glNormalPointerData decode");
3152 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3153 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3154 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3155 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
3156 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
3157 if (useChecksum) {
3158 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
3159 "gles1_decoder_context_t::decode, OP_glNormalPointerData: GL checksumCalculator failure\n");
3160 }
3161 #ifdef CHECK_GL_ERRORS
3162 GLint err = this->glGetError();
3163 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointerData\n", err);
3164 #endif
3165 DECODER_DEBUG_LOG("gles1(%p): glNormalPointerData(type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3166 this->glNormalPointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3167 SET_LASTCALL("glNormalPointerData");
3168 android::base::endTrace();
3169 break;
3170 }
3171 case OP_glTexCoordPointerData: {
3172 android::base::beginTrace("glTexCoordPointerData decode");
3173 GLint var_unit = Unpack<GLint,uint32_t>(ptr + 8);
3174 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8 + 4);
3175 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3176 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
3177 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3178 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4, size_data);
3179 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_data);
3180 if (useChecksum) {
3181 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3182 "gles1_decoder_context_t::decode, OP_glTexCoordPointerData: GL checksumCalculator failure\n");
3183 }
3184 #ifdef CHECK_GL_ERRORS
3185 GLint err = this->glGetError();
3186 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointerData\n", err);
3187 #endif
3188 DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointerData(unit:%d size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_unit, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3189 this->glTexCoordPointerData(this, var_unit, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3190 SET_LASTCALL("glTexCoordPointerData");
3191 android::base::endTrace();
3192 break;
3193 }
3194 case OP_glPointSizePointerData: {
3195 android::base::beginTrace("glPointSizePointerData decode");
3196 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3197 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3198 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3199 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
3200 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
3201 if (useChecksum) {
3202 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
3203 "gles1_decoder_context_t::decode, OP_glPointSizePointerData: GL checksumCalculator failure\n");
3204 }
3205 #ifdef CHECK_GL_ERRORS
3206 GLint err = this->glGetError();
3207 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerData\n", err);
3208 #endif
3209 DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerData(type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3210 this->glPointSizePointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3211 SET_LASTCALL("glPointSizePointerData");
3212 android::base::endTrace();
3213 break;
3214 }
3215 case OP_glWeightPointerData: {
3216 android::base::beginTrace("glWeightPointerData decode");
3217 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3218 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3219 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3220 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3221 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3222 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3223 if (useChecksum) {
3224 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3225 "gles1_decoder_context_t::decode, OP_glWeightPointerData: GL checksumCalculator failure\n");
3226 }
3227 #ifdef CHECK_GL_ERRORS
3228 GLint err = this->glGetError();
3229 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerData\n", err);
3230 #endif
3231 DECODER_DEBUG_LOG("gles1(%p): glWeightPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3232 this->glWeightPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3233 SET_LASTCALL("glWeightPointerData");
3234 android::base::endTrace();
3235 break;
3236 }
3237 case OP_glMatrixIndexPointerData: {
3238 android::base::beginTrace("glMatrixIndexPointerData decode");
3239 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3240 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3241 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3242 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3243 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3244 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3245 if (useChecksum) {
3246 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3247 "gles1_decoder_context_t::decode, OP_glMatrixIndexPointerData: GL checksumCalculator failure\n");
3248 }
3249 #ifdef CHECK_GL_ERRORS
3250 GLint err = this->glGetError();
3251 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerData\n", err);
3252 #endif
3253 DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3254 this->glMatrixIndexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3255 SET_LASTCALL("glMatrixIndexPointerData");
3256 android::base::endTrace();
3257 break;
3258 }
3259 case OP_glDrawElementsOffset: {
3260 android::base::beginTrace("glDrawElementsOffset decode");
3261 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
3262 GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3263 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3264 GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3265 if (useChecksum) {
3266 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3267 "gles1_decoder_context_t::decode, OP_glDrawElementsOffset: GL checksumCalculator failure\n");
3268 }
3269 #ifdef CHECK_GL_ERRORS
3270 GLint err = this->glGetError();
3271 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElementsOffset\n", err);
3272 #endif
3273 DECODER_DEBUG_LOG("gles1(%p): glDrawElementsOffset(mode:0x%08x count:%d type:0x%08x offset:%u )", stream, var_mode, var_count, var_type, var_offset);
3274 this->glDrawElementsOffset(this, var_mode, var_count, var_type, var_offset);
3275 SET_LASTCALL("glDrawElementsOffset");
3276 android::base::endTrace();
3277 break;
3278 }
3279 case OP_glDrawElementsData: {
3280 android::base::beginTrace("glDrawElementsData decode");
3281 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
3282 GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3283 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3284 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3285 InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3286 GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3287 if (useChecksum) {
3288 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3289 "gles1_decoder_context_t::decode, OP_glDrawElementsData: GL checksumCalculator failure\n");
3290 }
3291 #ifdef CHECK_GL_ERRORS
3292 GLint err = this->glGetError();
3293 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElementsData\n", err);
3294 #endif
3295 DECODER_DEBUG_LOG("gles1(%p): glDrawElementsData(mode:0x%08x count:%d type:0x%08x data:%p(%u) datalen:%u )", stream, var_mode, var_count, var_type, (void*)(inptr_data.get()), size_data, var_datalen);
3296 this->glDrawElementsData(this, var_mode, var_count, var_type, (void*)(inptr_data.get()), var_datalen);
3297 SET_LASTCALL("glDrawElementsData");
3298 android::base::endTrace();
3299 break;
3300 }
3301 case OP_glGetCompressedTextureFormats: {
3302 android::base::beginTrace("glGetCompressedTextureFormats decode");
3303 int var_count = Unpack<int,uint32_t>(ptr + 8);
3304 uint32_t size_formats __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3305 if (useChecksum) {
3306 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3307 "gles1_decoder_context_t::decode, OP_glGetCompressedTextureFormats: GL checksumCalculator failure\n");
3308 }
3309 size_t totalTmpSize = size_formats;
3310 totalTmpSize += checksumSize;
3311 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3312 OutputBuffer outptr_formats(&tmpBuf[0], size_formats);
3313 #ifdef CHECK_GL_ERRORS
3314 GLint err = this->glGetError();
3315 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetCompressedTextureFormats\n", err);
3316 #endif
3317 DECODER_DEBUG_LOG("gles1(%p): glGetCompressedTextureFormats(count:%d formats:%p(%u) )", stream, var_count, (GLint*)(outptr_formats.get()), size_formats);
3318 this->glGetCompressedTextureFormats(this, var_count, (GLint*)(outptr_formats.get()));
3319 outptr_formats.flush();
3320 if (useChecksum) {
3321 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3322 }
3323 stream->flush();
3324 SET_LASTCALL("glGetCompressedTextureFormats");
3325 android::base::endTrace();
3326 break;
3327 }
3328 case OP_glFinishRoundTrip: {
3329 android::base::beginTrace("glFinishRoundTrip decode");
3330 if (useChecksum) {
3331 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
3332 "gles1_decoder_context_t::decode, OP_glFinishRoundTrip: GL checksumCalculator failure\n");
3333 }
3334 size_t totalTmpSize = sizeof(int);
3335 totalTmpSize += checksumSize;
3336 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3337 #ifdef CHECK_GL_ERRORS
3338 GLint err = this->glGetError();
3339 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinishRoundTrip\n", err);
3340 #endif
3341 DECODER_DEBUG_LOG("gles1(%p): glFinishRoundTrip()", stream);
3342 *(int *)(&tmpBuf[0]) = this->glFinishRoundTrip(this);
3343 if (useChecksum) {
3344 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3345 }
3346 stream->flush();
3347 SET_LASTCALL("glFinishRoundTrip");
3348 android::base::endTrace();
3349 break;
3350 }
3351 case OP_glBlendEquationSeparateOES: {
3352 android::base::beginTrace("glBlendEquationSeparateOES decode");
3353 GLenum var_modeRGB = Unpack<GLenum,uint32_t>(ptr + 8);
3354 GLenum var_modeAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3355 if (useChecksum) {
3356 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3357 "gles1_decoder_context_t::decode, OP_glBlendEquationSeparateOES: GL checksumCalculator failure\n");
3358 }
3359 #ifdef CHECK_GL_ERRORS
3360 GLint err = this->glGetError();
3361 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendEquationSeparateOES\n", err);
3362 #endif
3363 DECODER_DEBUG_LOG("gles1(%p): glBlendEquationSeparateOES(modeRGB:0x%08x modeAlpha:0x%08x )", stream, var_modeRGB, var_modeAlpha);
3364 this->glBlendEquationSeparateOES(var_modeRGB, var_modeAlpha);
3365 SET_LASTCALL("glBlendEquationSeparateOES");
3366 android::base::endTrace();
3367 break;
3368 }
3369 case OP_glBlendFuncSeparateOES: {
3370 android::base::beginTrace("glBlendFuncSeparateOES decode");
3371 GLenum var_srcRGB = Unpack<GLenum,uint32_t>(ptr + 8);
3372 GLenum var_dstRGB = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3373 GLenum var_srcAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3374 GLenum var_dstAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4);
3375 if (useChecksum) {
3376 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3377 "gles1_decoder_context_t::decode, OP_glBlendFuncSeparateOES: GL checksumCalculator failure\n");
3378 }
3379 #ifdef CHECK_GL_ERRORS
3380 GLint err = this->glGetError();
3381 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendFuncSeparateOES\n", err);
3382 #endif
3383 DECODER_DEBUG_LOG("gles1(%p): glBlendFuncSeparateOES(srcRGB:0x%08x dstRGB:0x%08x srcAlpha:0x%08x dstAlpha:0x%08x )", stream, var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
3384 this->glBlendFuncSeparateOES(var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
3385 SET_LASTCALL("glBlendFuncSeparateOES");
3386 android::base::endTrace();
3387 break;
3388 }
3389 case OP_glBlendEquationOES: {
3390 android::base::beginTrace("glBlendEquationOES decode");
3391 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
3392 if (useChecksum) {
3393 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
3394 "gles1_decoder_context_t::decode, OP_glBlendEquationOES: GL checksumCalculator failure\n");
3395 }
3396 #ifdef CHECK_GL_ERRORS
3397 GLint err = this->glGetError();
3398 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendEquationOES\n", err);
3399 #endif
3400 DECODER_DEBUG_LOG("gles1(%p): glBlendEquationOES(mode:0x%08x )", stream, var_mode);
3401 this->glBlendEquationOES(var_mode);
3402 SET_LASTCALL("glBlendEquationOES");
3403 android::base::endTrace();
3404 break;
3405 }
3406 case OP_glDrawTexsOES: {
3407 android::base::beginTrace("glDrawTexsOES decode");
3408 GLshort var_x = Unpack<GLshort,uint16_t>(ptr + 8);
3409 GLshort var_y = Unpack<GLshort,uint16_t>(ptr + 8 + 2);
3410 GLshort var_z = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2);
3411 GLshort var_width = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2 + 2);
3412 GLshort var_height = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2 + 2 + 2);
3413 if (useChecksum) {
3414 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 2 + 2 + 2 + 2 + 2, ptr + 8 + 2 + 2 + 2 + 2 + 2, checksumSize,
3415 "gles1_decoder_context_t::decode, OP_glDrawTexsOES: GL checksumCalculator failure\n");
3416 }
3417 #ifdef CHECK_GL_ERRORS
3418 GLint err = this->glGetError();
3419 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexsOES\n", err);
3420 #endif
3421 DECODER_DEBUG_LOG("gles1(%p): glDrawTexsOES(x:%d y:%d z:%d width:%d height:%d )", stream, var_x, var_y, var_z, var_width, var_height);
3422 this->glDrawTexsOES(var_x, var_y, var_z, var_width, var_height);
3423 SET_LASTCALL("glDrawTexsOES");
3424 android::base::endTrace();
3425 break;
3426 }
3427 case OP_glDrawTexiOES: {
3428 android::base::beginTrace("glDrawTexiOES decode");
3429 GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
3430 GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
3431 GLint var_z = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
3432 GLint var_width = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3433 GLint var_height = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3434 if (useChecksum) {
3435 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
3436 "gles1_decoder_context_t::decode, OP_glDrawTexiOES: GL checksumCalculator failure\n");
3437 }
3438 #ifdef CHECK_GL_ERRORS
3439 GLint err = this->glGetError();
3440 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexiOES\n", err);
3441 #endif
3442 DECODER_DEBUG_LOG("gles1(%p): glDrawTexiOES(x:%d y:%d z:%d width:%d height:%d )", stream, var_x, var_y, var_z, var_width, var_height);
3443 this->glDrawTexiOES(var_x, var_y, var_z, var_width, var_height);
3444 SET_LASTCALL("glDrawTexiOES");
3445 android::base::endTrace();
3446 break;
3447 }
3448 case OP_glDrawTexxOES: {
3449 android::base::beginTrace("glDrawTexxOES decode");
3450 GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
3451 GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3452 GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
3453 GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
3454 GLfixed var_height = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3455 if (useChecksum) {
3456 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
3457 "gles1_decoder_context_t::decode, OP_glDrawTexxOES: GL checksumCalculator failure\n");
3458 }
3459 #ifdef CHECK_GL_ERRORS
3460 GLint err = this->glGetError();
3461 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexxOES\n", err);
3462 #endif
3463 DECODER_DEBUG_LOG("gles1(%p): glDrawTexxOES(x:0x%08x y:0x%08x z:0x%08x width:0x%08x height:0x%08x )", stream, var_x, var_y, var_z, var_width, var_height);
3464 this->glDrawTexxOES(var_x, var_y, var_z, var_width, var_height);
3465 SET_LASTCALL("glDrawTexxOES");
3466 android::base::endTrace();
3467 break;
3468 }
3469 case OP_glDrawTexsvOES: {
3470 android::base::beginTrace("glDrawTexsvOES decode");
3471 uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3472 InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3473 if (useChecksum) {
3474 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3475 "gles1_decoder_context_t::decode, OP_glDrawTexsvOES: GL checksumCalculator failure\n");
3476 }
3477 #ifdef CHECK_GL_ERRORS
3478 GLint err = this->glGetError();
3479 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexsvOES\n", err);
3480 #endif
3481 DECODER_DEBUG_LOG("gles1(%p): glDrawTexsvOES(coords:%p(%u) )", stream, (const GLshort*)(inptr_coords.get()), size_coords);
3482 this->glDrawTexsvOES((const GLshort*)(inptr_coords.get()));
3483 SET_LASTCALL("glDrawTexsvOES");
3484 android::base::endTrace();
3485 break;
3486 }
3487 case OP_glDrawTexivOES: {
3488 android::base::beginTrace("glDrawTexivOES decode");
3489 uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3490 InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3491 if (useChecksum) {
3492 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3493 "gles1_decoder_context_t::decode, OP_glDrawTexivOES: GL checksumCalculator failure\n");
3494 }
3495 #ifdef CHECK_GL_ERRORS
3496 GLint err = this->glGetError();
3497 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexivOES\n", err);
3498 #endif
3499 DECODER_DEBUG_LOG("gles1(%p): glDrawTexivOES(coords:%p(%u) )", stream, (const GLint*)(inptr_coords.get()), size_coords);
3500 this->glDrawTexivOES((const GLint*)(inptr_coords.get()));
3501 SET_LASTCALL("glDrawTexivOES");
3502 android::base::endTrace();
3503 break;
3504 }
3505 case OP_glDrawTexxvOES: {
3506 android::base::beginTrace("glDrawTexxvOES decode");
3507 uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3508 InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3509 if (useChecksum) {
3510 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3511 "gles1_decoder_context_t::decode, OP_glDrawTexxvOES: GL checksumCalculator failure\n");
3512 }
3513 #ifdef CHECK_GL_ERRORS
3514 GLint err = this->glGetError();
3515 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexxvOES\n", err);
3516 #endif
3517 DECODER_DEBUG_LOG("gles1(%p): glDrawTexxvOES(coords:%p(%u) )", stream, (const GLfixed*)(inptr_coords.get()), size_coords);
3518 this->glDrawTexxvOES((const GLfixed*)(inptr_coords.get()));
3519 SET_LASTCALL("glDrawTexxvOES");
3520 android::base::endTrace();
3521 break;
3522 }
3523 case OP_glDrawTexfOES: {
3524 android::base::beginTrace("glDrawTexfOES decode");
3525 GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
3526 GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
3527 GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
3528 GLfloat var_width = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
3529 GLfloat var_height = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3530 if (useChecksum) {
3531 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
3532 "gles1_decoder_context_t::decode, OP_glDrawTexfOES: GL checksumCalculator failure\n");
3533 }
3534 #ifdef CHECK_GL_ERRORS
3535 GLint err = this->glGetError();
3536 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexfOES\n", err);
3537 #endif
3538 DECODER_DEBUG_LOG("gles1(%p): glDrawTexfOES(x:%f y:%f z:%f width:%f height:%f )", stream, var_x, var_y, var_z, var_width, var_height);
3539 this->glDrawTexfOES(var_x, var_y, var_z, var_width, var_height);
3540 SET_LASTCALL("glDrawTexfOES");
3541 android::base::endTrace();
3542 break;
3543 }
3544 case OP_glDrawTexfvOES: {
3545 android::base::beginTrace("glDrawTexfvOES decode");
3546 uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3547 InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3548 if (useChecksum) {
3549 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3550 "gles1_decoder_context_t::decode, OP_glDrawTexfvOES: GL checksumCalculator failure\n");
3551 }
3552 #ifdef CHECK_GL_ERRORS
3553 GLint err = this->glGetError();
3554 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexfvOES\n", err);
3555 #endif
3556 DECODER_DEBUG_LOG("gles1(%p): glDrawTexfvOES(coords:%p(%u) )", stream, (const GLfloat*)(inptr_coords.get()), size_coords);
3557 this->glDrawTexfvOES((const GLfloat*)(inptr_coords.get()));
3558 SET_LASTCALL("glDrawTexfvOES");
3559 android::base::endTrace();
3560 break;
3561 }
3562 case OP_glEGLImageTargetTexture2DOES: {
3563 android::base::beginTrace("glEGLImageTargetTexture2DOES decode");
3564 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
3565 GLeglImageOES var_image = Unpack<GLeglImageOES,uint32_t>(ptr + 8 + 4);
3566 if (useChecksum) {
3567 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3568 "gles1_decoder_context_t::decode, OP_glEGLImageTargetTexture2DOES: GL checksumCalculator failure\n");
3569 }
3570 #ifdef CHECK_GL_ERRORS
3571 GLint err = this->glGetError();
3572 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEGLImageTargetTexture2DOES\n", err);
3573 #endif
3574 DECODER_DEBUG_LOG("gles1(%p): glEGLImageTargetTexture2DOES(target:0x%08x image:%p )", stream, var_target, var_image);
3575 this->glEGLImageTargetTexture2DOES(var_target, var_image);
3576 SET_LASTCALL("glEGLImageTargetTexture2DOES");
3577 android::base::endTrace();
3578 break;
3579 }
3580 case OP_glEGLImageTargetRenderbufferStorageOES: {
3581 android::base::beginTrace("glEGLImageTargetRenderbufferStorageOES decode");
3582 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
3583 GLeglImageOES var_image = Unpack<GLeglImageOES,uint32_t>(ptr + 8 + 4);
3584 if (useChecksum) {
3585 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3586 "gles1_decoder_context_t::decode, OP_glEGLImageTargetRenderbufferStorageOES: GL checksumCalculator failure\n");
3587 }
3588 #ifdef CHECK_GL_ERRORS
3589 GLint err = this->glGetError();
3590 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEGLImageTargetRenderbufferStorageOES\n", err);
3591 #endif
3592 DECODER_DEBUG_LOG("gles1(%p): glEGLImageTargetRenderbufferStorageOES(target:0x%08x image:%p )", stream, var_target, var_image);
3593 this->glEGLImageTargetRenderbufferStorageOES(var_target, var_image);
3594 SET_LASTCALL("glEGLImageTargetRenderbufferStorageOES");
3595 android::base::endTrace();
3596 break;
3597 }
3598 case OP_glAlphaFuncxOES: {
3599 android::base::beginTrace("glAlphaFuncxOES decode");
3600 GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
3601 GLclampx var_ref = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
3602 if (useChecksum) {
3603 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3604 "gles1_decoder_context_t::decode, OP_glAlphaFuncxOES: GL checksumCalculator failure\n");
3605 }
3606 #ifdef CHECK_GL_ERRORS
3607 GLint err = this->glGetError();
3608 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFuncxOES\n", err);
3609 #endif
3610 DECODER_DEBUG_LOG("gles1(%p): glAlphaFuncxOES(func:0x%08x ref:0x%08x )", stream, var_func, var_ref);
3611 this->glAlphaFuncxOES(var_func, var_ref);
3612 SET_LASTCALL("glAlphaFuncxOES");
3613 android::base::endTrace();
3614 break;
3615 }
3616 case OP_glClearColorxOES: {
3617 android::base::beginTrace("glClearColorxOES decode");
3618 GLclampx var_red = Unpack<GLclampx,uint32_t>(ptr + 8);
3619 GLclampx var_green = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
3620 GLclampx var_blue = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4);
3621 GLclampx var_alpha = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4 + 4);
3622 if (useChecksum) {
3623 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3624 "gles1_decoder_context_t::decode, OP_glClearColorxOES: GL checksumCalculator failure\n");
3625 }
3626 #ifdef CHECK_GL_ERRORS
3627 GLint err = this->glGetError();
3628 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColorxOES\n", err);
3629 #endif
3630 DECODER_DEBUG_LOG("gles1(%p): glClearColorxOES(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
3631 this->glClearColorxOES(var_red, var_green, var_blue, var_alpha);
3632 SET_LASTCALL("glClearColorxOES");
3633 android::base::endTrace();
3634 break;
3635 }
3636 case OP_glClearDepthxOES: {
3637 android::base::beginTrace("glClearDepthxOES decode");
3638 GLclampx var_depth = Unpack<GLclampx,uint32_t>(ptr + 8);
3639 if (useChecksum) {
3640 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
3641 "gles1_decoder_context_t::decode, OP_glClearDepthxOES: GL checksumCalculator failure\n");
3642 }
3643 #ifdef CHECK_GL_ERRORS
3644 GLint err = this->glGetError();
3645 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthxOES\n", err);
3646 #endif
3647 DECODER_DEBUG_LOG("gles1(%p): glClearDepthxOES(depth:0x%08x )", stream, var_depth);
3648 this->glClearDepthxOES(var_depth);
3649 SET_LASTCALL("glClearDepthxOES");
3650 android::base::endTrace();
3651 break;
3652 }
3653 case OP_glClipPlanexOES: {
3654 android::base::beginTrace("glClipPlanexOES decode");
3655 GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
3656 uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3657 InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
3658 if (useChecksum) {
3659 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
3660 "gles1_decoder_context_t::decode, OP_glClipPlanexOES: GL checksumCalculator failure\n");
3661 }
3662 #ifdef CHECK_GL_ERRORS
3663 GLint err = this->glGetError();
3664 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanexOES\n", err);
3665 #endif
3666 DECODER_DEBUG_LOG("gles1(%p): glClipPlanexOES(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfixed*)(inptr_equation.get()), size_equation);
3667 this->glClipPlanexOES(var_plane, (const GLfixed*)(inptr_equation.get()));
3668 SET_LASTCALL("glClipPlanexOES");
3669 android::base::endTrace();
3670 break;
3671 }
3672 case OP_glClipPlanexIMG: {
3673 android::base::beginTrace("glClipPlanexIMG decode");
3674 GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
3675 uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3676 InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
3677 if (useChecksum) {
3678 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
3679 "gles1_decoder_context_t::decode, OP_glClipPlanexIMG: GL checksumCalculator failure\n");
3680 }
3681 #ifdef CHECK_GL_ERRORS
3682 GLint err = this->glGetError();
3683 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanexIMG\n", err);
3684 #endif
3685 DECODER_DEBUG_LOG("gles1(%p): glClipPlanexIMG(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfixed*)(inptr_equation.get()), size_equation);
3686 this->glClipPlanexIMG(var_plane, (const GLfixed*)(inptr_equation.get()));
3687 SET_LASTCALL("glClipPlanexIMG");
3688 android::base::endTrace();
3689 break;
3690 }
3691 case OP_glColor4xOES: {
3692 android::base::beginTrace("glColor4xOES decode");
3693 GLfixed var_red = Unpack<GLfixed,uint32_t>(ptr + 8);
3694 GLfixed var_green = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3695 GLfixed var_blue = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
3696 GLfixed var_alpha = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
3697 if (useChecksum) {
3698 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3699 "gles1_decoder_context_t::decode, OP_glColor4xOES: GL checksumCalculator failure\n");
3700 }
3701 #ifdef CHECK_GL_ERRORS
3702 GLint err = this->glGetError();
3703 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4xOES\n", err);
3704 #endif
3705 DECODER_DEBUG_LOG("gles1(%p): glColor4xOES(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
3706 this->glColor4xOES(var_red, var_green, var_blue, var_alpha);
3707 SET_LASTCALL("glColor4xOES");
3708 android::base::endTrace();
3709 break;
3710 }
3711 case OP_glDepthRangexOES: {
3712 android::base::beginTrace("glDepthRangexOES decode");
3713 GLclampx var_zNear = Unpack<GLclampx,uint32_t>(ptr + 8);
3714 GLclampx var_zFar = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
3715 if (useChecksum) {
3716 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3717 "gles1_decoder_context_t::decode, OP_glDepthRangexOES: GL checksumCalculator failure\n");
3718 }
3719 #ifdef CHECK_GL_ERRORS
3720 GLint err = this->glGetError();
3721 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangexOES\n", err);
3722 #endif
3723 DECODER_DEBUG_LOG("gles1(%p): glDepthRangexOES(zNear:0x%08x zFar:0x%08x )", stream, var_zNear, var_zFar);
3724 this->glDepthRangexOES(var_zNear, var_zFar);
3725 SET_LASTCALL("glDepthRangexOES");
3726 android::base::endTrace();
3727 break;
3728 }
3729 case OP_glFogxOES: {
3730 android::base::beginTrace("glFogxOES decode");
3731 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3732 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3733 if (useChecksum) {
3734 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3735 "gles1_decoder_context_t::decode, OP_glFogxOES: GL checksumCalculator failure\n");
3736 }
3737 #ifdef CHECK_GL_ERRORS
3738 GLint err = this->glGetError();
3739 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxOES\n", err);
3740 #endif
3741 DECODER_DEBUG_LOG("gles1(%p): glFogxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
3742 this->glFogxOES(var_pname, var_param);
3743 SET_LASTCALL("glFogxOES");
3744 android::base::endTrace();
3745 break;
3746 }
3747 case OP_glFogxvOES: {
3748 android::base::beginTrace("glFogxvOES decode");
3749 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3750 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3751 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
3752 if (useChecksum) {
3753 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
3754 "gles1_decoder_context_t::decode, OP_glFogxvOES: GL checksumCalculator failure\n");
3755 }
3756 #ifdef CHECK_GL_ERRORS
3757 GLint err = this->glGetError();
3758 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxvOES\n", err);
3759 #endif
3760 DECODER_DEBUG_LOG("gles1(%p): glFogxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
3761 this->glFogxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
3762 SET_LASTCALL("glFogxvOES");
3763 android::base::endTrace();
3764 break;
3765 }
3766 case OP_glFrustumxOES: {
3767 android::base::beginTrace("glFrustumxOES decode");
3768 GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
3769 GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3770 GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
3771 GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
3772 GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3773 GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
3774 if (useChecksum) {
3775 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
3776 "gles1_decoder_context_t::decode, OP_glFrustumxOES: GL checksumCalculator failure\n");
3777 }
3778 #ifdef CHECK_GL_ERRORS
3779 GLint err = this->glGetError();
3780 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumxOES\n", err);
3781 #endif
3782 DECODER_DEBUG_LOG("gles1(%p): glFrustumxOES(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
3783 this->glFrustumxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
3784 SET_LASTCALL("glFrustumxOES");
3785 android::base::endTrace();
3786 break;
3787 }
3788 case OP_glGetClipPlanexOES: {
3789 android::base::beginTrace("glGetClipPlanexOES decode");
3790 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3791 uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3792 if (useChecksum) {
3793 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3794 "gles1_decoder_context_t::decode, OP_glGetClipPlanexOES: GL checksumCalculator failure\n");
3795 }
3796 size_t totalTmpSize = size_eqn;
3797 totalTmpSize += checksumSize;
3798 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3799 OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
3800 #ifdef CHECK_GL_ERRORS
3801 GLint err = this->glGetError();
3802 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanexOES\n", err);
3803 #endif
3804 DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanexOES(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_eqn.get()), size_eqn);
3805 this->glGetClipPlanexOES(var_pname, (GLfixed*)(outptr_eqn.get()));
3806 outptr_eqn.flush();
3807 if (useChecksum) {
3808 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3809 }
3810 stream->flush();
3811 SET_LASTCALL("glGetClipPlanexOES");
3812 android::base::endTrace();
3813 break;
3814 }
3815 case OP_glGetClipPlanex: {
3816 android::base::beginTrace("glGetClipPlanex decode");
3817 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3818 uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3819 if (useChecksum) {
3820 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3821 "gles1_decoder_context_t::decode, OP_glGetClipPlanex: GL checksumCalculator failure\n");
3822 }
3823 size_t totalTmpSize = size_eqn;
3824 totalTmpSize += checksumSize;
3825 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3826 OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
3827 #ifdef CHECK_GL_ERRORS
3828 GLint err = this->glGetError();
3829 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanex\n", err);
3830 #endif
3831 DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanex(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_eqn.get()), size_eqn);
3832 this->glGetClipPlanex(var_pname, (GLfixed*)(outptr_eqn.get()));
3833 outptr_eqn.flush();
3834 if (useChecksum) {
3835 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3836 }
3837 stream->flush();
3838 SET_LASTCALL("glGetClipPlanex");
3839 android::base::endTrace();
3840 break;
3841 }
3842 case OP_glGetFixedvOES: {
3843 android::base::beginTrace("glGetFixedvOES decode");
3844 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3845 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3846 if (useChecksum) {
3847 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3848 "gles1_decoder_context_t::decode, OP_glGetFixedvOES: GL checksumCalculator failure\n");
3849 }
3850 size_t totalTmpSize = size_params;
3851 totalTmpSize += checksumSize;
3852 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3853 OutputBuffer outptr_params(&tmpBuf[0], size_params);
3854 #ifdef CHECK_GL_ERRORS
3855 GLint err = this->glGetError();
3856 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFixedvOES\n", err);
3857 #endif
3858 DECODER_DEBUG_LOG("gles1(%p): glGetFixedvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3859 this->glGetFixedvOES(var_pname, (GLfixed*)(outptr_params.get()));
3860 outptr_params.flush();
3861 if (useChecksum) {
3862 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3863 }
3864 stream->flush();
3865 SET_LASTCALL("glGetFixedvOES");
3866 android::base::endTrace();
3867 break;
3868 }
3869 case OP_glGetLightxvOES: {
3870 android::base::beginTrace("glGetLightxvOES decode");
3871 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
3872 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3873 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3874 if (useChecksum) {
3875 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3876 "gles1_decoder_context_t::decode, OP_glGetLightxvOES: GL checksumCalculator failure\n");
3877 }
3878 size_t totalTmpSize = size_params;
3879 totalTmpSize += checksumSize;
3880 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3881 OutputBuffer outptr_params(&tmpBuf[0], size_params);
3882 #ifdef CHECK_GL_ERRORS
3883 GLint err = this->glGetError();
3884 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightxvOES\n", err);
3885 #endif
3886 DECODER_DEBUG_LOG("gles1(%p): glGetLightxvOES(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3887 this->glGetLightxvOES(var_light, var_pname, (GLfixed*)(outptr_params.get()));
3888 outptr_params.flush();
3889 if (useChecksum) {
3890 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3891 }
3892 stream->flush();
3893 SET_LASTCALL("glGetLightxvOES");
3894 android::base::endTrace();
3895 break;
3896 }
3897 case OP_glGetMaterialxvOES: {
3898 android::base::beginTrace("glGetMaterialxvOES decode");
3899 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
3900 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3901 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3902 if (useChecksum) {
3903 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3904 "gles1_decoder_context_t::decode, OP_glGetMaterialxvOES: GL checksumCalculator failure\n");
3905 }
3906 size_t totalTmpSize = size_params;
3907 totalTmpSize += checksumSize;
3908 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3909 OutputBuffer outptr_params(&tmpBuf[0], size_params);
3910 #ifdef CHECK_GL_ERRORS
3911 GLint err = this->glGetError();
3912 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialxvOES\n", err);
3913 #endif
3914 DECODER_DEBUG_LOG("gles1(%p): glGetMaterialxvOES(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3915 this->glGetMaterialxvOES(var_face, var_pname, (GLfixed*)(outptr_params.get()));
3916 outptr_params.flush();
3917 if (useChecksum) {
3918 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3919 }
3920 stream->flush();
3921 SET_LASTCALL("glGetMaterialxvOES");
3922 android::base::endTrace();
3923 break;
3924 }
3925 case OP_glGetTexEnvxvOES: {
3926 android::base::beginTrace("glGetTexEnvxvOES decode");
3927 GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
3928 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3929 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3930 if (useChecksum) {
3931 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3932 "gles1_decoder_context_t::decode, OP_glGetTexEnvxvOES: GL checksumCalculator failure\n");
3933 }
3934 size_t totalTmpSize = size_params;
3935 totalTmpSize += checksumSize;
3936 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3937 OutputBuffer outptr_params(&tmpBuf[0], size_params);
3938 #ifdef CHECK_GL_ERRORS
3939 GLint err = this->glGetError();
3940 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvxvOES\n", err);
3941 #endif
3942 DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvxvOES(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3943 this->glGetTexEnvxvOES(var_env, var_pname, (GLfixed*)(outptr_params.get()));
3944 outptr_params.flush();
3945 if (useChecksum) {
3946 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3947 }
3948 stream->flush();
3949 SET_LASTCALL("glGetTexEnvxvOES");
3950 android::base::endTrace();
3951 break;
3952 }
3953 case OP_glGetTexParameterxvOES: {
3954 android::base::beginTrace("glGetTexParameterxvOES decode");
3955 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
3956 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3957 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3958 if (useChecksum) {
3959 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3960 "gles1_decoder_context_t::decode, OP_glGetTexParameterxvOES: GL checksumCalculator failure\n");
3961 }
3962 size_t totalTmpSize = size_params;
3963 totalTmpSize += checksumSize;
3964 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3965 OutputBuffer outptr_params(&tmpBuf[0], size_params);
3966 #ifdef CHECK_GL_ERRORS
3967 GLint err = this->glGetError();
3968 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterxvOES\n", err);
3969 #endif
3970 DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3971 this->glGetTexParameterxvOES(var_target, var_pname, (GLfixed*)(outptr_params.get()));
3972 outptr_params.flush();
3973 if (useChecksum) {
3974 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3975 }
3976 stream->flush();
3977 SET_LASTCALL("glGetTexParameterxvOES");
3978 android::base::endTrace();
3979 break;
3980 }
3981 case OP_glLightModelxOES: {
3982 android::base::beginTrace("glLightModelxOES decode");
3983 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3984 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3985 if (useChecksum) {
3986 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3987 "gles1_decoder_context_t::decode, OP_glLightModelxOES: GL checksumCalculator failure\n");
3988 }
3989 #ifdef CHECK_GL_ERRORS
3990 GLint err = this->glGetError();
3991 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxOES\n", err);
3992 #endif
3993 DECODER_DEBUG_LOG("gles1(%p): glLightModelxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
3994 this->glLightModelxOES(var_pname, var_param);
3995 SET_LASTCALL("glLightModelxOES");
3996 android::base::endTrace();
3997 break;
3998 }
3999 case OP_glLightModelxvOES: {
4000 android::base::beginTrace("glLightModelxvOES decode");
4001 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
4002 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4003 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
4004 if (useChecksum) {
4005 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
4006 "gles1_decoder_context_t::decode, OP_glLightModelxvOES: GL checksumCalculator failure\n");
4007 }
4008 #ifdef CHECK_GL_ERRORS
4009 GLint err = this->glGetError();
4010 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxvOES\n", err);
4011 #endif
4012 DECODER_DEBUG_LOG("gles1(%p): glLightModelxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4013 this->glLightModelxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
4014 SET_LASTCALL("glLightModelxvOES");
4015 android::base::endTrace();
4016 break;
4017 }
4018 case OP_glLightxOES: {
4019 android::base::beginTrace("glLightxOES decode");
4020 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
4021 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4022 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4023 if (useChecksum) {
4024 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4025 "gles1_decoder_context_t::decode, OP_glLightxOES: GL checksumCalculator failure\n");
4026 }
4027 #ifdef CHECK_GL_ERRORS
4028 GLint err = this->glGetError();
4029 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxOES\n", err);
4030 #endif
4031 DECODER_DEBUG_LOG("gles1(%p): glLightxOES(light:0x%08x pname:0x%08x param:0x%08x )", stream, var_light, var_pname, var_param);
4032 this->glLightxOES(var_light, var_pname, var_param);
4033 SET_LASTCALL("glLightxOES");
4034 android::base::endTrace();
4035 break;
4036 }
4037 case OP_glLightxvOES: {
4038 android::base::beginTrace("glLightxvOES decode");
4039 GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
4040 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4041 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4042 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4043 if (useChecksum) {
4044 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4045 "gles1_decoder_context_t::decode, OP_glLightxvOES: GL checksumCalculator failure\n");
4046 }
4047 #ifdef CHECK_GL_ERRORS
4048 GLint err = this->glGetError();
4049 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxvOES\n", err);
4050 #endif
4051 DECODER_DEBUG_LOG("gles1(%p): glLightxvOES(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4052 this->glLightxvOES(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
4053 SET_LASTCALL("glLightxvOES");
4054 android::base::endTrace();
4055 break;
4056 }
4057 case OP_glLineWidthxOES: {
4058 android::base::beginTrace("glLineWidthxOES decode");
4059 GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8);
4060 if (useChecksum) {
4061 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4062 "gles1_decoder_context_t::decode, OP_glLineWidthxOES: GL checksumCalculator failure\n");
4063 }
4064 #ifdef CHECK_GL_ERRORS
4065 GLint err = this->glGetError();
4066 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidthxOES\n", err);
4067 #endif
4068 DECODER_DEBUG_LOG("gles1(%p): glLineWidthxOES(width:0x%08x )", stream, var_width);
4069 this->glLineWidthxOES(var_width);
4070 SET_LASTCALL("glLineWidthxOES");
4071 android::base::endTrace();
4072 break;
4073 }
4074 case OP_glLoadMatrixxOES: {
4075 android::base::beginTrace("glLoadMatrixxOES decode");
4076 uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
4077 InputBuffer inptr_m(ptr + 8 + 4, size_m);
4078 if (useChecksum) {
4079 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
4080 "gles1_decoder_context_t::decode, OP_glLoadMatrixxOES: GL checksumCalculator failure\n");
4081 }
4082 #ifdef CHECK_GL_ERRORS
4083 GLint err = this->glGetError();
4084 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixxOES\n", err);
4085 #endif
4086 DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixxOES(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
4087 this->glLoadMatrixxOES((const GLfixed*)(inptr_m.get()));
4088 SET_LASTCALL("glLoadMatrixxOES");
4089 android::base::endTrace();
4090 break;
4091 }
4092 case OP_glMaterialxOES: {
4093 android::base::beginTrace("glMaterialxOES decode");
4094 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
4095 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4096 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4097 if (useChecksum) {
4098 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4099 "gles1_decoder_context_t::decode, OP_glMaterialxOES: GL checksumCalculator failure\n");
4100 }
4101 #ifdef CHECK_GL_ERRORS
4102 GLint err = this->glGetError();
4103 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxOES\n", err);
4104 #endif
4105 DECODER_DEBUG_LOG("gles1(%p): glMaterialxOES(face:0x%08x pname:0x%08x param:0x%08x )", stream, var_face, var_pname, var_param);
4106 this->glMaterialxOES(var_face, var_pname, var_param);
4107 SET_LASTCALL("glMaterialxOES");
4108 android::base::endTrace();
4109 break;
4110 }
4111 case OP_glMaterialxvOES: {
4112 android::base::beginTrace("glMaterialxvOES decode");
4113 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
4114 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4115 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4116 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4117 if (useChecksum) {
4118 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4119 "gles1_decoder_context_t::decode, OP_glMaterialxvOES: GL checksumCalculator failure\n");
4120 }
4121 #ifdef CHECK_GL_ERRORS
4122 GLint err = this->glGetError();
4123 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxvOES\n", err);
4124 #endif
4125 DECODER_DEBUG_LOG("gles1(%p): glMaterialxvOES(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4126 this->glMaterialxvOES(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
4127 SET_LASTCALL("glMaterialxvOES");
4128 android::base::endTrace();
4129 break;
4130 }
4131 case OP_glMultMatrixxOES: {
4132 android::base::beginTrace("glMultMatrixxOES decode");
4133 uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
4134 InputBuffer inptr_m(ptr + 8 + 4, size_m);
4135 if (useChecksum) {
4136 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
4137 "gles1_decoder_context_t::decode, OP_glMultMatrixxOES: GL checksumCalculator failure\n");
4138 }
4139 #ifdef CHECK_GL_ERRORS
4140 GLint err = this->glGetError();
4141 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixxOES\n", err);
4142 #endif
4143 DECODER_DEBUG_LOG("gles1(%p): glMultMatrixxOES(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
4144 this->glMultMatrixxOES((const GLfixed*)(inptr_m.get()));
4145 SET_LASTCALL("glMultMatrixxOES");
4146 android::base::endTrace();
4147 break;
4148 }
4149 case OP_glMultiTexCoord4xOES: {
4150 android::base::beginTrace("glMultiTexCoord4xOES decode");
4151 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4152 GLfixed var_s = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4153 GLfixed var_t = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4154 GLfixed var_r = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
4155 GLfixed var_q = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4156 if (useChecksum) {
4157 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
4158 "gles1_decoder_context_t::decode, OP_glMultiTexCoord4xOES: GL checksumCalculator failure\n");
4159 }
4160 #ifdef CHECK_GL_ERRORS
4161 GLint err = this->glGetError();
4162 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4xOES\n", err);
4163 #endif
4164 DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4xOES(target:0x%08x s:0x%08x t:0x%08x r:0x%08x q:0x%08x )", stream, var_target, var_s, var_t, var_r, var_q);
4165 this->glMultiTexCoord4xOES(var_target, var_s, var_t, var_r, var_q);
4166 SET_LASTCALL("glMultiTexCoord4xOES");
4167 android::base::endTrace();
4168 break;
4169 }
4170 case OP_glNormal3xOES: {
4171 android::base::beginTrace("glNormal3xOES decode");
4172 GLfixed var_nx = Unpack<GLfixed,uint32_t>(ptr + 8);
4173 GLfixed var_ny = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4174 GLfixed var_nz = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4175 if (useChecksum) {
4176 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4177 "gles1_decoder_context_t::decode, OP_glNormal3xOES: GL checksumCalculator failure\n");
4178 }
4179 #ifdef CHECK_GL_ERRORS
4180 GLint err = this->glGetError();
4181 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3xOES\n", err);
4182 #endif
4183 DECODER_DEBUG_LOG("gles1(%p): glNormal3xOES(nx:0x%08x ny:0x%08x nz:0x%08x )", stream, var_nx, var_ny, var_nz);
4184 this->glNormal3xOES(var_nx, var_ny, var_nz);
4185 SET_LASTCALL("glNormal3xOES");
4186 android::base::endTrace();
4187 break;
4188 }
4189 case OP_glOrthoxOES: {
4190 android::base::beginTrace("glOrthoxOES decode");
4191 GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
4192 GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4193 GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4194 GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
4195 GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4196 GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
4197 if (useChecksum) {
4198 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
4199 "gles1_decoder_context_t::decode, OP_glOrthoxOES: GL checksumCalculator failure\n");
4200 }
4201 #ifdef CHECK_GL_ERRORS
4202 GLint err = this->glGetError();
4203 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthoxOES\n", err);
4204 #endif
4205 DECODER_DEBUG_LOG("gles1(%p): glOrthoxOES(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4206 this->glOrthoxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4207 SET_LASTCALL("glOrthoxOES");
4208 android::base::endTrace();
4209 break;
4210 }
4211 case OP_glPointParameterxOES: {
4212 android::base::beginTrace("glPointParameterxOES decode");
4213 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
4214 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4215 if (useChecksum) {
4216 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4217 "gles1_decoder_context_t::decode, OP_glPointParameterxOES: GL checksumCalculator failure\n");
4218 }
4219 #ifdef CHECK_GL_ERRORS
4220 GLint err = this->glGetError();
4221 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxOES\n", err);
4222 #endif
4223 DECODER_DEBUG_LOG("gles1(%p): glPointParameterxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
4224 this->glPointParameterxOES(var_pname, var_param);
4225 SET_LASTCALL("glPointParameterxOES");
4226 android::base::endTrace();
4227 break;
4228 }
4229 case OP_glPointParameterxvOES: {
4230 android::base::beginTrace("glPointParameterxvOES decode");
4231 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
4232 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4233 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
4234 if (useChecksum) {
4235 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
4236 "gles1_decoder_context_t::decode, OP_glPointParameterxvOES: GL checksumCalculator failure\n");
4237 }
4238 #ifdef CHECK_GL_ERRORS
4239 GLint err = this->glGetError();
4240 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxvOES\n", err);
4241 #endif
4242 DECODER_DEBUG_LOG("gles1(%p): glPointParameterxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4243 this->glPointParameterxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
4244 SET_LASTCALL("glPointParameterxvOES");
4245 android::base::endTrace();
4246 break;
4247 }
4248 case OP_glPointSizexOES: {
4249 android::base::beginTrace("glPointSizexOES decode");
4250 GLfixed var_size = Unpack<GLfixed,uint32_t>(ptr + 8);
4251 if (useChecksum) {
4252 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4253 "gles1_decoder_context_t::decode, OP_glPointSizexOES: GL checksumCalculator failure\n");
4254 }
4255 #ifdef CHECK_GL_ERRORS
4256 GLint err = this->glGetError();
4257 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizexOES\n", err);
4258 #endif
4259 DECODER_DEBUG_LOG("gles1(%p): glPointSizexOES(size:0x%08x )", stream, var_size);
4260 this->glPointSizexOES(var_size);
4261 SET_LASTCALL("glPointSizexOES");
4262 android::base::endTrace();
4263 break;
4264 }
4265 case OP_glPolygonOffsetxOES: {
4266 android::base::beginTrace("glPolygonOffsetxOES decode");
4267 GLfixed var_factor = Unpack<GLfixed,uint32_t>(ptr + 8);
4268 GLfixed var_units = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4269 if (useChecksum) {
4270 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4271 "gles1_decoder_context_t::decode, OP_glPolygonOffsetxOES: GL checksumCalculator failure\n");
4272 }
4273 #ifdef CHECK_GL_ERRORS
4274 GLint err = this->glGetError();
4275 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffsetxOES\n", err);
4276 #endif
4277 DECODER_DEBUG_LOG("gles1(%p): glPolygonOffsetxOES(factor:0x%08x units:0x%08x )", stream, var_factor, var_units);
4278 this->glPolygonOffsetxOES(var_factor, var_units);
4279 SET_LASTCALL("glPolygonOffsetxOES");
4280 android::base::endTrace();
4281 break;
4282 }
4283 case OP_glRotatexOES: {
4284 android::base::beginTrace("glRotatexOES decode");
4285 GLfixed var_angle = Unpack<GLfixed,uint32_t>(ptr + 8);
4286 GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4287 GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4288 GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
4289 if (useChecksum) {
4290 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4291 "gles1_decoder_context_t::decode, OP_glRotatexOES: GL checksumCalculator failure\n");
4292 }
4293 #ifdef CHECK_GL_ERRORS
4294 GLint err = this->glGetError();
4295 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatexOES\n", err);
4296 #endif
4297 DECODER_DEBUG_LOG("gles1(%p): glRotatexOES(angle:0x%08x x:0x%08x y:0x%08x z:0x%08x )", stream, var_angle, var_x, var_y, var_z);
4298 this->glRotatexOES(var_angle, var_x, var_y, var_z);
4299 SET_LASTCALL("glRotatexOES");
4300 android::base::endTrace();
4301 break;
4302 }
4303 case OP_glSampleCoveragexOES: {
4304 android::base::beginTrace("glSampleCoveragexOES decode");
4305 GLclampx var_value = Unpack<GLclampx,uint32_t>(ptr + 8);
4306 GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
4307 if (useChecksum) {
4308 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
4309 "gles1_decoder_context_t::decode, OP_glSampleCoveragexOES: GL checksumCalculator failure\n");
4310 }
4311 #ifdef CHECK_GL_ERRORS
4312 GLint err = this->glGetError();
4313 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoveragexOES\n", err);
4314 #endif
4315 DECODER_DEBUG_LOG("gles1(%p): glSampleCoveragexOES(value:0x%08x invert:%d )", stream, var_value, var_invert);
4316 this->glSampleCoveragexOES(var_value, var_invert);
4317 SET_LASTCALL("glSampleCoveragexOES");
4318 android::base::endTrace();
4319 break;
4320 }
4321 case OP_glScalexOES: {
4322 android::base::beginTrace("glScalexOES decode");
4323 GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
4324 GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4325 GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4326 if (useChecksum) {
4327 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4328 "gles1_decoder_context_t::decode, OP_glScalexOES: GL checksumCalculator failure\n");
4329 }
4330 #ifdef CHECK_GL_ERRORS
4331 GLint err = this->glGetError();
4332 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalexOES\n", err);
4333 #endif
4334 DECODER_DEBUG_LOG("gles1(%p): glScalexOES(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
4335 this->glScalexOES(var_x, var_y, var_z);
4336 SET_LASTCALL("glScalexOES");
4337 android::base::endTrace();
4338 break;
4339 }
4340 case OP_glTexEnvxOES: {
4341 android::base::beginTrace("glTexEnvxOES decode");
4342 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4343 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4344 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4345 if (useChecksum) {
4346 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4347 "gles1_decoder_context_t::decode, OP_glTexEnvxOES: GL checksumCalculator failure\n");
4348 }
4349 #ifdef CHECK_GL_ERRORS
4350 GLint err = this->glGetError();
4351 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxOES\n", err);
4352 #endif
4353 DECODER_DEBUG_LOG("gles1(%p): glTexEnvxOES(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
4354 this->glTexEnvxOES(var_target, var_pname, var_param);
4355 SET_LASTCALL("glTexEnvxOES");
4356 android::base::endTrace();
4357 break;
4358 }
4359 case OP_glTexEnvxvOES: {
4360 android::base::beginTrace("glTexEnvxvOES decode");
4361 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4362 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4363 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4364 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4365 if (useChecksum) {
4366 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4367 "gles1_decoder_context_t::decode, OP_glTexEnvxvOES: GL checksumCalculator failure\n");
4368 }
4369 #ifdef CHECK_GL_ERRORS
4370 GLint err = this->glGetError();
4371 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxvOES\n", err);
4372 #endif
4373 DECODER_DEBUG_LOG("gles1(%p): glTexEnvxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4374 this->glTexEnvxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
4375 SET_LASTCALL("glTexEnvxvOES");
4376 android::base::endTrace();
4377 break;
4378 }
4379 case OP_glTexParameterxOES: {
4380 android::base::beginTrace("glTexParameterxOES decode");
4381 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4382 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4383 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4384 if (useChecksum) {
4385 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4386 "gles1_decoder_context_t::decode, OP_glTexParameterxOES: GL checksumCalculator failure\n");
4387 }
4388 #ifdef CHECK_GL_ERRORS
4389 GLint err = this->glGetError();
4390 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxOES\n", err);
4391 #endif
4392 DECODER_DEBUG_LOG("gles1(%p): glTexParameterxOES(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
4393 this->glTexParameterxOES(var_target, var_pname, var_param);
4394 SET_LASTCALL("glTexParameterxOES");
4395 android::base::endTrace();
4396 break;
4397 }
4398 case OP_glTexParameterxvOES: {
4399 android::base::beginTrace("glTexParameterxvOES decode");
4400 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4401 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4402 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4403 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4404 if (useChecksum) {
4405 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4406 "gles1_decoder_context_t::decode, OP_glTexParameterxvOES: GL checksumCalculator failure\n");
4407 }
4408 #ifdef CHECK_GL_ERRORS
4409 GLint err = this->glGetError();
4410 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxvOES\n", err);
4411 #endif
4412 DECODER_DEBUG_LOG("gles1(%p): glTexParameterxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4413 this->glTexParameterxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
4414 SET_LASTCALL("glTexParameterxvOES");
4415 android::base::endTrace();
4416 break;
4417 }
4418 case OP_glTranslatexOES: {
4419 android::base::beginTrace("glTranslatexOES decode");
4420 GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
4421 GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4422 GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4423 if (useChecksum) {
4424 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4425 "gles1_decoder_context_t::decode, OP_glTranslatexOES: GL checksumCalculator failure\n");
4426 }
4427 #ifdef CHECK_GL_ERRORS
4428 GLint err = this->glGetError();
4429 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatexOES\n", err);
4430 #endif
4431 DECODER_DEBUG_LOG("gles1(%p): glTranslatexOES(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
4432 this->glTranslatexOES(var_x, var_y, var_z);
4433 SET_LASTCALL("glTranslatexOES");
4434 android::base::endTrace();
4435 break;
4436 }
4437 case OP_glIsRenderbufferOES: {
4438 android::base::beginTrace("glIsRenderbufferOES decode");
4439 GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8);
4440 if (useChecksum) {
4441 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4442 "gles1_decoder_context_t::decode, OP_glIsRenderbufferOES: GL checksumCalculator failure\n");
4443 }
4444 size_t totalTmpSize = sizeof(GLboolean);
4445 totalTmpSize += checksumSize;
4446 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4447 #ifdef CHECK_GL_ERRORS
4448 GLint err = this->glGetError();
4449 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsRenderbufferOES\n", err);
4450 #endif
4451 DECODER_DEBUG_LOG("gles1(%p): glIsRenderbufferOES(renderbuffer:%u )", stream, var_renderbuffer);
4452 *(GLboolean *)(&tmpBuf[0]) = this->glIsRenderbufferOES(var_renderbuffer);
4453 if (useChecksum) {
4454 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4455 }
4456 stream->flush();
4457 SET_LASTCALL("glIsRenderbufferOES");
4458 android::base::endTrace();
4459 break;
4460 }
4461 case OP_glBindRenderbufferOES: {
4462 android::base::beginTrace("glBindRenderbufferOES decode");
4463 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4464 GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
4465 if (useChecksum) {
4466 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4467 "gles1_decoder_context_t::decode, OP_glBindRenderbufferOES: GL checksumCalculator failure\n");
4468 }
4469 #ifdef CHECK_GL_ERRORS
4470 GLint err = this->glGetError();
4471 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindRenderbufferOES\n", err);
4472 #endif
4473 DECODER_DEBUG_LOG("gles1(%p): glBindRenderbufferOES(target:0x%08x renderbuffer:%u )", stream, var_target, var_renderbuffer);
4474 this->glBindRenderbufferOES(var_target, var_renderbuffer);
4475 SET_LASTCALL("glBindRenderbufferOES");
4476 android::base::endTrace();
4477 break;
4478 }
4479 case OP_glDeleteRenderbuffersOES: {
4480 android::base::beginTrace("glDeleteRenderbuffersOES decode");
4481 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4482 uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4483 InputBuffer inptr_renderbuffers(ptr + 8 + 4 + 4, size_renderbuffers);
4484 if (useChecksum) {
4485 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_renderbuffers, ptr + 8 + 4 + 4 + size_renderbuffers, checksumSize,
4486 "gles1_decoder_context_t::decode, OP_glDeleteRenderbuffersOES: GL checksumCalculator failure\n");
4487 }
4488 #ifdef CHECK_GL_ERRORS
4489 GLint err = this->glGetError();
4490 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteRenderbuffersOES\n", err);
4491 #endif
4492 DECODER_DEBUG_LOG("gles1(%p): glDeleteRenderbuffersOES(n:%d renderbuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_renderbuffers.get()), size_renderbuffers);
4493 this->glDeleteRenderbuffersOES_dec(this, var_n, (const GLuint*)(inptr_renderbuffers.get()));
4494 SET_LASTCALL("glDeleteRenderbuffersOES");
4495 android::base::endTrace();
4496 break;
4497 }
4498 case OP_glGenRenderbuffersOES: {
4499 android::base::beginTrace("glGenRenderbuffersOES decode");
4500 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4501 uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4502 if (useChecksum) {
4503 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4504 "gles1_decoder_context_t::decode, OP_glGenRenderbuffersOES: GL checksumCalculator failure\n");
4505 }
4506 size_t totalTmpSize = size_renderbuffers;
4507 totalTmpSize += checksumSize;
4508 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4509 OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
4510 #ifdef CHECK_GL_ERRORS
4511 GLint err = this->glGetError();
4512 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenRenderbuffersOES\n", err);
4513 #endif
4514 DECODER_DEBUG_LOG("gles1(%p): glGenRenderbuffersOES(n:%d renderbuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_renderbuffers.get()), size_renderbuffers);
4515 this->glGenRenderbuffersOES_dec(this, var_n, (GLuint*)(outptr_renderbuffers.get()));
4516 outptr_renderbuffers.flush();
4517 if (useChecksum) {
4518 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4519 }
4520 stream->flush();
4521 SET_LASTCALL("glGenRenderbuffersOES");
4522 android::base::endTrace();
4523 break;
4524 }
4525 case OP_glRenderbufferStorageOES: {
4526 android::base::beginTrace("glRenderbufferStorageOES decode");
4527 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4528 GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4529 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
4530 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
4531 if (useChecksum) {
4532 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4533 "gles1_decoder_context_t::decode, OP_glRenderbufferStorageOES: GL checksumCalculator failure\n");
4534 }
4535 #ifdef CHECK_GL_ERRORS
4536 GLint err = this->glGetError();
4537 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRenderbufferStorageOES\n", err);
4538 #endif
4539 DECODER_DEBUG_LOG("gles1(%p): glRenderbufferStorageOES(target:0x%08x internalformat:0x%08x width:%d height:%d )", stream, var_target, var_internalformat, var_width, var_height);
4540 this->glRenderbufferStorageOES(var_target, var_internalformat, var_width, var_height);
4541 SET_LASTCALL("glRenderbufferStorageOES");
4542 android::base::endTrace();
4543 break;
4544 }
4545 case OP_glGetRenderbufferParameterivOES: {
4546 android::base::beginTrace("glGetRenderbufferParameterivOES decode");
4547 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4548 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4549 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4550 if (useChecksum) {
4551 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4552 "gles1_decoder_context_t::decode, OP_glGetRenderbufferParameterivOES: GL checksumCalculator failure\n");
4553 }
4554 size_t totalTmpSize = size_params;
4555 totalTmpSize += checksumSize;
4556 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4557 OutputBuffer outptr_params(&tmpBuf[0], size_params);
4558 #ifdef CHECK_GL_ERRORS
4559 GLint err = this->glGetError();
4560 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetRenderbufferParameterivOES\n", err);
4561 #endif
4562 DECODER_DEBUG_LOG("gles1(%p): glGetRenderbufferParameterivOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
4563 this->glGetRenderbufferParameterivOES(var_target, var_pname, (GLint*)(outptr_params.get()));
4564 outptr_params.flush();
4565 if (useChecksum) {
4566 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4567 }
4568 stream->flush();
4569 SET_LASTCALL("glGetRenderbufferParameterivOES");
4570 android::base::endTrace();
4571 break;
4572 }
4573 case OP_glIsFramebufferOES: {
4574 android::base::beginTrace("glIsFramebufferOES decode");
4575 GLuint var_framebuffer = Unpack<GLuint,uint32_t>(ptr + 8);
4576 if (useChecksum) {
4577 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4578 "gles1_decoder_context_t::decode, OP_glIsFramebufferOES: GL checksumCalculator failure\n");
4579 }
4580 size_t totalTmpSize = sizeof(GLboolean);
4581 totalTmpSize += checksumSize;
4582 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4583 #ifdef CHECK_GL_ERRORS
4584 GLint err = this->glGetError();
4585 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsFramebufferOES\n", err);
4586 #endif
4587 DECODER_DEBUG_LOG("gles1(%p): glIsFramebufferOES(framebuffer:%u )", stream, var_framebuffer);
4588 *(GLboolean *)(&tmpBuf[0]) = this->glIsFramebufferOES(var_framebuffer);
4589 if (useChecksum) {
4590 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4591 }
4592 stream->flush();
4593 SET_LASTCALL("glIsFramebufferOES");
4594 android::base::endTrace();
4595 break;
4596 }
4597 case OP_glBindFramebufferOES: {
4598 android::base::beginTrace("glBindFramebufferOES decode");
4599 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4600 GLuint var_framebuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
4601 if (useChecksum) {
4602 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4603 "gles1_decoder_context_t::decode, OP_glBindFramebufferOES: GL checksumCalculator failure\n");
4604 }
4605 #ifdef CHECK_GL_ERRORS
4606 GLint err = this->glGetError();
4607 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindFramebufferOES\n", err);
4608 #endif
4609 DECODER_DEBUG_LOG("gles1(%p): glBindFramebufferOES(target:0x%08x framebuffer:%u )", stream, var_target, var_framebuffer);
4610 this->glBindFramebufferOES(var_target, var_framebuffer);
4611 SET_LASTCALL("glBindFramebufferOES");
4612 android::base::endTrace();
4613 break;
4614 }
4615 case OP_glDeleteFramebuffersOES: {
4616 android::base::beginTrace("glDeleteFramebuffersOES decode");
4617 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4618 uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4619 InputBuffer inptr_framebuffers(ptr + 8 + 4 + 4, size_framebuffers);
4620 if (useChecksum) {
4621 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_framebuffers, ptr + 8 + 4 + 4 + size_framebuffers, checksumSize,
4622 "gles1_decoder_context_t::decode, OP_glDeleteFramebuffersOES: GL checksumCalculator failure\n");
4623 }
4624 #ifdef CHECK_GL_ERRORS
4625 GLint err = this->glGetError();
4626 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteFramebuffersOES\n", err);
4627 #endif
4628 DECODER_DEBUG_LOG("gles1(%p): glDeleteFramebuffersOES(n:%d framebuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_framebuffers.get()), size_framebuffers);
4629 this->glDeleteFramebuffersOES_dec(this, var_n, (const GLuint*)(inptr_framebuffers.get()));
4630 SET_LASTCALL("glDeleteFramebuffersOES");
4631 android::base::endTrace();
4632 break;
4633 }
4634 case OP_glGenFramebuffersOES: {
4635 android::base::beginTrace("glGenFramebuffersOES decode");
4636 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4637 uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4638 if (useChecksum) {
4639 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4640 "gles1_decoder_context_t::decode, OP_glGenFramebuffersOES: GL checksumCalculator failure\n");
4641 }
4642 size_t totalTmpSize = size_framebuffers;
4643 totalTmpSize += checksumSize;
4644 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4645 OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
4646 #ifdef CHECK_GL_ERRORS
4647 GLint err = this->glGetError();
4648 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenFramebuffersOES\n", err);
4649 #endif
4650 DECODER_DEBUG_LOG("gles1(%p): glGenFramebuffersOES(n:%d framebuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_framebuffers.get()), size_framebuffers);
4651 this->glGenFramebuffersOES_dec(this, var_n, (GLuint*)(outptr_framebuffers.get()));
4652 outptr_framebuffers.flush();
4653 if (useChecksum) {
4654 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4655 }
4656 stream->flush();
4657 SET_LASTCALL("glGenFramebuffersOES");
4658 android::base::endTrace();
4659 break;
4660 }
4661 case OP_glCheckFramebufferStatusOES: {
4662 android::base::beginTrace("glCheckFramebufferStatusOES decode");
4663 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4664 if (useChecksum) {
4665 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4666 "gles1_decoder_context_t::decode, OP_glCheckFramebufferStatusOES: GL checksumCalculator failure\n");
4667 }
4668 size_t totalTmpSize = sizeof(GLenum);
4669 totalTmpSize += checksumSize;
4670 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4671 #ifdef CHECK_GL_ERRORS
4672 GLint err = this->glGetError();
4673 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCheckFramebufferStatusOES\n", err);
4674 #endif
4675 DECODER_DEBUG_LOG("gles1(%p): glCheckFramebufferStatusOES(target:0x%08x )", stream, var_target);
4676 *(GLenum *)(&tmpBuf[0]) = this->glCheckFramebufferStatusOES(var_target);
4677 if (useChecksum) {
4678 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4679 }
4680 stream->flush();
4681 SET_LASTCALL("glCheckFramebufferStatusOES");
4682 android::base::endTrace();
4683 break;
4684 }
4685 case OP_glFramebufferRenderbufferOES: {
4686 android::base::beginTrace("glFramebufferRenderbufferOES decode");
4687 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4688 GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4689 GLenum var_renderbuffertarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
4690 GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
4691 if (useChecksum) {
4692 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4693 "gles1_decoder_context_t::decode, OP_glFramebufferRenderbufferOES: GL checksumCalculator failure\n");
4694 }
4695 #ifdef CHECK_GL_ERRORS
4696 GLint err = this->glGetError();
4697 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferRenderbufferOES\n", err);
4698 #endif
4699 DECODER_DEBUG_LOG("gles1(%p): glFramebufferRenderbufferOES(target:0x%08x attachment:0x%08x renderbuffertarget:0x%08x renderbuffer:%u )", stream, var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
4700 this->glFramebufferRenderbufferOES(var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
4701 SET_LASTCALL("glFramebufferRenderbufferOES");
4702 android::base::endTrace();
4703 break;
4704 }
4705 case OP_glFramebufferTexture2DOES: {
4706 android::base::beginTrace("glFramebufferTexture2DOES decode");
4707 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4708 GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4709 GLenum var_textarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
4710 GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
4711 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4712 if (useChecksum) {
4713 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
4714 "gles1_decoder_context_t::decode, OP_glFramebufferTexture2DOES: GL checksumCalculator failure\n");
4715 }
4716 #ifdef CHECK_GL_ERRORS
4717 GLint err = this->glGetError();
4718 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferTexture2DOES\n", err);
4719 #endif
4720 DECODER_DEBUG_LOG("gles1(%p): glFramebufferTexture2DOES(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level);
4721 this->glFramebufferTexture2DOES(var_target, var_attachment, var_textarget, var_texture, var_level);
4722 SET_LASTCALL("glFramebufferTexture2DOES");
4723 android::base::endTrace();
4724 break;
4725 }
4726 case OP_glGetFramebufferAttachmentParameterivOES: {
4727 android::base::beginTrace("glGetFramebufferAttachmentParameterivOES decode");
4728 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4729 GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4730 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
4731 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
4732 if (useChecksum) {
4733 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4734 "gles1_decoder_context_t::decode, OP_glGetFramebufferAttachmentParameterivOES: GL checksumCalculator failure\n");
4735 }
4736 size_t totalTmpSize = size_params;
4737 totalTmpSize += checksumSize;
4738 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4739 OutputBuffer outptr_params(&tmpBuf[0], size_params);
4740 #ifdef CHECK_GL_ERRORS
4741 GLint err = this->glGetError();
4742 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFramebufferAttachmentParameterivOES\n", err);
4743 #endif
4744 DECODER_DEBUG_LOG("gles1(%p): glGetFramebufferAttachmentParameterivOES(target:0x%08x attachment:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()), size_params);
4745 this->glGetFramebufferAttachmentParameterivOES(var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()));
4746 outptr_params.flush();
4747 if (useChecksum) {
4748 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4749 }
4750 stream->flush();
4751 SET_LASTCALL("glGetFramebufferAttachmentParameterivOES");
4752 android::base::endTrace();
4753 break;
4754 }
4755 case OP_glGenerateMipmapOES: {
4756 android::base::beginTrace("glGenerateMipmapOES decode");
4757 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4758 if (useChecksum) {
4759 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4760 "gles1_decoder_context_t::decode, OP_glGenerateMipmapOES: GL checksumCalculator failure\n");
4761 }
4762 #ifdef CHECK_GL_ERRORS
4763 GLint err = this->glGetError();
4764 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenerateMipmapOES\n", err);
4765 #endif
4766 DECODER_DEBUG_LOG("gles1(%p): glGenerateMipmapOES(target:0x%08x )", stream, var_target);
4767 this->glGenerateMipmapOES(var_target);
4768 SET_LASTCALL("glGenerateMipmapOES");
4769 android::base::endTrace();
4770 break;
4771 }
4772 case OP_glMapBufferOES: {
4773 android::base::beginTrace("glMapBufferOES decode");
4774 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4775 GLenum var_access = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4776 if (useChecksum) {
4777 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4778 "gles1_decoder_context_t::decode, OP_glMapBufferOES: GL checksumCalculator failure\n");
4779 }
4780 #ifdef CHECK_GL_ERRORS
4781 GLint err = this->glGetError();
4782 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMapBufferOES\n", err);
4783 #endif
4784 DECODER_DEBUG_LOG("gles1(%p): glMapBufferOES(target:0x%08x access:0x%08x )", stream, var_target, var_access);
4785 this->glMapBufferOES(var_target, var_access);
4786 SET_LASTCALL("glMapBufferOES");
4787 android::base::endTrace();
4788 break;
4789 }
4790 case OP_glUnmapBufferOES: {
4791 android::base::beginTrace("glUnmapBufferOES decode");
4792 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4793 if (useChecksum) {
4794 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4795 "gles1_decoder_context_t::decode, OP_glUnmapBufferOES: GL checksumCalculator failure\n");
4796 }
4797 size_t totalTmpSize = sizeof(GLboolean);
4798 totalTmpSize += checksumSize;
4799 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4800 #ifdef CHECK_GL_ERRORS
4801 GLint err = this->glGetError();
4802 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glUnmapBufferOES\n", err);
4803 #endif
4804 DECODER_DEBUG_LOG("gles1(%p): glUnmapBufferOES(target:0x%08x )", stream, var_target);
4805 *(GLboolean *)(&tmpBuf[0]) = this->glUnmapBufferOES(var_target);
4806 if (useChecksum) {
4807 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4808 }
4809 stream->flush();
4810 SET_LASTCALL("glUnmapBufferOES");
4811 android::base::endTrace();
4812 break;
4813 }
4814 case OP_glGetBufferPointervOES: {
4815 android::base::beginTrace("glGetBufferPointervOES decode");
4816 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4817 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4818 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4819 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4820 if (useChecksum) {
4821 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4822 "gles1_decoder_context_t::decode, OP_glGetBufferPointervOES: GL checksumCalculator failure\n");
4823 }
4824 #ifdef CHECK_GL_ERRORS
4825 GLint err = this->glGetError();
4826 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBufferPointervOES\n", err);
4827 #endif
4828 DECODER_DEBUG_LOG("gles1(%p): glGetBufferPointervOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLvoid**)(inptr_params.get()), size_params);
4829 this->glGetBufferPointervOES(var_target, var_pname, (GLvoid**)(inptr_params.get()));
4830 SET_LASTCALL("glGetBufferPointervOES");
4831 android::base::endTrace();
4832 break;
4833 }
4834 case OP_glCurrentPaletteMatrixOES: {
4835 android::base::beginTrace("glCurrentPaletteMatrixOES decode");
4836 GLuint var_matrixpaletteindex = Unpack<GLuint,uint32_t>(ptr + 8);
4837 if (useChecksum) {
4838 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4839 "gles1_decoder_context_t::decode, OP_glCurrentPaletteMatrixOES: GL checksumCalculator failure\n");
4840 }
4841 #ifdef CHECK_GL_ERRORS
4842 GLint err = this->glGetError();
4843 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCurrentPaletteMatrixOES\n", err);
4844 #endif
4845 DECODER_DEBUG_LOG("gles1(%p): glCurrentPaletteMatrixOES(matrixpaletteindex:%u )", stream, var_matrixpaletteindex);
4846 this->glCurrentPaletteMatrixOES(var_matrixpaletteindex);
4847 SET_LASTCALL("glCurrentPaletteMatrixOES");
4848 android::base::endTrace();
4849 break;
4850 }
4851 case OP_glLoadPaletteFromModelViewMatrixOES: {
4852 android::base::beginTrace("glLoadPaletteFromModelViewMatrixOES decode");
4853 if (useChecksum) {
4854 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
4855 "gles1_decoder_context_t::decode, OP_glLoadPaletteFromModelViewMatrixOES: GL checksumCalculator failure\n");
4856 }
4857 #ifdef CHECK_GL_ERRORS
4858 GLint err = this->glGetError();
4859 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadPaletteFromModelViewMatrixOES\n", err);
4860 #endif
4861 DECODER_DEBUG_LOG("gles1(%p): glLoadPaletteFromModelViewMatrixOES()", stream);
4862 this->glLoadPaletteFromModelViewMatrixOES();
4863 SET_LASTCALL("glLoadPaletteFromModelViewMatrixOES");
4864 android::base::endTrace();
4865 break;
4866 }
4867 case OP_glMatrixIndexPointerOES: {
4868 android::base::beginTrace("glMatrixIndexPointerOES decode");
4869 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
4870 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4871 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
4872 uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
4873 InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
4874 if (useChecksum) {
4875 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
4876 "gles1_decoder_context_t::decode, OP_glMatrixIndexPointerOES: GL checksumCalculator failure\n");
4877 }
4878 #ifdef CHECK_GL_ERRORS
4879 GLint err = this->glGetError();
4880 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerOES\n", err);
4881 #endif
4882 DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerOES(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
4883 this->glMatrixIndexPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
4884 SET_LASTCALL("glMatrixIndexPointerOES");
4885 android::base::endTrace();
4886 break;
4887 }
4888 case OP_glWeightPointerOES: {
4889 android::base::beginTrace("glWeightPointerOES decode");
4890 GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
4891 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4892 GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
4893 uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
4894 InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
4895 if (useChecksum) {
4896 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
4897 "gles1_decoder_context_t::decode, OP_glWeightPointerOES: GL checksumCalculator failure\n");
4898 }
4899 #ifdef CHECK_GL_ERRORS
4900 GLint err = this->glGetError();
4901 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerOES\n", err);
4902 #endif
4903 DECODER_DEBUG_LOG("gles1(%p): glWeightPointerOES(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
4904 this->glWeightPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
4905 SET_LASTCALL("glWeightPointerOES");
4906 android::base::endTrace();
4907 break;
4908 }
4909 case OP_glQueryMatrixxOES: {
4910 android::base::beginTrace("glQueryMatrixxOES decode");
4911 uint32_t size_mantissa __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
4912 uint32_t size_exponent __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4913 if (useChecksum) {
4914 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4915 "gles1_decoder_context_t::decode, OP_glQueryMatrixxOES: GL checksumCalculator failure\n");
4916 }
4917 size_t totalTmpSize = size_mantissa;
4918 totalTmpSize += size_exponent;
4919 totalTmpSize += sizeof(GLbitfield);
4920 totalTmpSize += checksumSize;
4921 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4922 OutputBuffer outptr_mantissa(&tmpBuf[0], size_mantissa);
4923 OutputBuffer outptr_exponent(&tmpBuf[0 + size_mantissa], size_exponent);
4924 #ifdef CHECK_GL_ERRORS
4925 GLint err = this->glGetError();
4926 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glQueryMatrixxOES\n", err);
4927 #endif
4928 DECODER_DEBUG_LOG("gles1(%p): glQueryMatrixxOES(mantissa:%p(%u) exponent:%p(%u) )", stream, (GLfixed*)(outptr_mantissa.get()), size_mantissa, (GLint*)(outptr_exponent.get()), size_exponent);
4929 *(GLbitfield *)(&tmpBuf[0 + size_mantissa + size_exponent]) = this->glQueryMatrixxOES((GLfixed*)(outptr_mantissa.get()), (GLint*)(outptr_exponent.get()));
4930 outptr_mantissa.flush();
4931 outptr_exponent.flush();
4932 if (useChecksum) {
4933 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4934 }
4935 stream->flush();
4936 SET_LASTCALL("glQueryMatrixxOES");
4937 android::base::endTrace();
4938 break;
4939 }
4940 case OP_glDepthRangefOES: {
4941 android::base::beginTrace("glDepthRangefOES decode");
4942 GLclampf var_zNear = Unpack<GLclampf,uint32_t>(ptr + 8);
4943 GLclampf var_zFar = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
4944 if (useChecksum) {
4945 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4946 "gles1_decoder_context_t::decode, OP_glDepthRangefOES: GL checksumCalculator failure\n");
4947 }
4948 #ifdef CHECK_GL_ERRORS
4949 GLint err = this->glGetError();
4950 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangefOES\n", err);
4951 #endif
4952 DECODER_DEBUG_LOG("gles1(%p): glDepthRangefOES(zNear:%f zFar:%f )", stream, var_zNear, var_zFar);
4953 this->glDepthRangefOES(var_zNear, var_zFar);
4954 SET_LASTCALL("glDepthRangefOES");
4955 android::base::endTrace();
4956 break;
4957 }
4958 case OP_glFrustumfOES: {
4959 android::base::beginTrace("glFrustumfOES decode");
4960 GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
4961 GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
4962 GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
4963 GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
4964 GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4965 GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
4966 if (useChecksum) {
4967 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
4968 "gles1_decoder_context_t::decode, OP_glFrustumfOES: GL checksumCalculator failure\n");
4969 }
4970 #ifdef CHECK_GL_ERRORS
4971 GLint err = this->glGetError();
4972 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumfOES\n", err);
4973 #endif
4974 DECODER_DEBUG_LOG("gles1(%p): glFrustumfOES(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4975 this->glFrustumfOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4976 SET_LASTCALL("glFrustumfOES");
4977 android::base::endTrace();
4978 break;
4979 }
4980 case OP_glOrthofOES: {
4981 android::base::beginTrace("glOrthofOES decode");
4982 GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
4983 GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
4984 GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
4985 GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
4986 GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4987 GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
4988 if (useChecksum) {
4989 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
4990 "gles1_decoder_context_t::decode, OP_glOrthofOES: GL checksumCalculator failure\n");
4991 }
4992 #ifdef CHECK_GL_ERRORS
4993 GLint err = this->glGetError();
4994 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthofOES\n", err);
4995 #endif
4996 DECODER_DEBUG_LOG("gles1(%p): glOrthofOES(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4997 this->glOrthofOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4998 SET_LASTCALL("glOrthofOES");
4999 android::base::endTrace();
5000 break;
5001 }
5002 case OP_glClipPlanefOES: {
5003 android::base::beginTrace("glClipPlanefOES decode");
5004 GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
5005 uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5006 InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
5007 if (useChecksum) {
5008 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
5009 "gles1_decoder_context_t::decode, OP_glClipPlanefOES: GL checksumCalculator failure\n");
5010 }
5011 #ifdef CHECK_GL_ERRORS
5012 GLint err = this->glGetError();
5013 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanefOES\n", err);
5014 #endif
5015 DECODER_DEBUG_LOG("gles1(%p): glClipPlanefOES(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
5016 this->glClipPlanefOES(var_plane, (const GLfloat*)(inptr_equation.get()));
5017 SET_LASTCALL("glClipPlanefOES");
5018 android::base::endTrace();
5019 break;
5020 }
5021 case OP_glClipPlanefIMG: {
5022 android::base::beginTrace("glClipPlanefIMG decode");
5023 GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
5024 uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5025 InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
5026 if (useChecksum) {
5027 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
5028 "gles1_decoder_context_t::decode, OP_glClipPlanefIMG: GL checksumCalculator failure\n");
5029 }
5030 #ifdef CHECK_GL_ERRORS
5031 GLint err = this->glGetError();
5032 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanefIMG\n", err);
5033 #endif
5034 DECODER_DEBUG_LOG("gles1(%p): glClipPlanefIMG(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
5035 this->glClipPlanefIMG(var_plane, (const GLfloat*)(inptr_equation.get()));
5036 SET_LASTCALL("glClipPlanefIMG");
5037 android::base::endTrace();
5038 break;
5039 }
5040 case OP_glGetClipPlanefOES: {
5041 android::base::beginTrace("glGetClipPlanefOES decode");
5042 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
5043 uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5044 if (useChecksum) {
5045 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
5046 "gles1_decoder_context_t::decode, OP_glGetClipPlanefOES: GL checksumCalculator failure\n");
5047 }
5048 size_t totalTmpSize = size_eqn;
5049 totalTmpSize += checksumSize;
5050 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5051 OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
5052 #ifdef CHECK_GL_ERRORS
5053 GLint err = this->glGetError();
5054 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanefOES\n", err);
5055 #endif
5056 DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanefOES(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_eqn.get()), size_eqn);
5057 this->glGetClipPlanefOES(var_pname, (GLfloat*)(outptr_eqn.get()));
5058 outptr_eqn.flush();
5059 if (useChecksum) {
5060 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5061 }
5062 stream->flush();
5063 SET_LASTCALL("glGetClipPlanefOES");
5064 android::base::endTrace();
5065 break;
5066 }
5067 case OP_glClearDepthfOES: {
5068 android::base::beginTrace("glClearDepthfOES decode");
5069 GLclampf var_depth = Unpack<GLclampf,uint32_t>(ptr + 8);
5070 if (useChecksum) {
5071 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5072 "gles1_decoder_context_t::decode, OP_glClearDepthfOES: GL checksumCalculator failure\n");
5073 }
5074 #ifdef CHECK_GL_ERRORS
5075 GLint err = this->glGetError();
5076 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthfOES\n", err);
5077 #endif
5078 DECODER_DEBUG_LOG("gles1(%p): glClearDepthfOES(depth:%f )", stream, var_depth);
5079 this->glClearDepthfOES(var_depth);
5080 SET_LASTCALL("glClearDepthfOES");
5081 android::base::endTrace();
5082 break;
5083 }
5084 case OP_glTexGenfOES: {
5085 android::base::beginTrace("glTexGenfOES decode");
5086 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5087 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5088 GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
5089 if (useChecksum) {
5090 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5091 "gles1_decoder_context_t::decode, OP_glTexGenfOES: GL checksumCalculator failure\n");
5092 }
5093 #ifdef CHECK_GL_ERRORS
5094 GLint err = this->glGetError();
5095 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenfOES\n", err);
5096 #endif
5097 DECODER_DEBUG_LOG("gles1(%p): glTexGenfOES(coord:0x%08x pname:0x%08x param:%f )", stream, var_coord, var_pname, var_param);
5098 this->glTexGenfOES(var_coord, var_pname, var_param);
5099 SET_LASTCALL("glTexGenfOES");
5100 android::base::endTrace();
5101 break;
5102 }
5103 case OP_glTexGenfvOES: {
5104 android::base::beginTrace("glTexGenfvOES decode");
5105 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5106 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5107 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5108 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5109 if (useChecksum) {
5110 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5111 "gles1_decoder_context_t::decode, OP_glTexGenfvOES: GL checksumCalculator failure\n");
5112 }
5113 #ifdef CHECK_GL_ERRORS
5114 GLint err = this->glGetError();
5115 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenfvOES\n", err);
5116 #endif
5117 DECODER_DEBUG_LOG("gles1(%p): glTexGenfvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
5118 this->glTexGenfvOES(var_coord, var_pname, (const GLfloat*)(inptr_params.get()));
5119 SET_LASTCALL("glTexGenfvOES");
5120 android::base::endTrace();
5121 break;
5122 }
5123 case OP_glTexGeniOES: {
5124 android::base::beginTrace("glTexGeniOES decode");
5125 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5126 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5127 GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5128 if (useChecksum) {
5129 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5130 "gles1_decoder_context_t::decode, OP_glTexGeniOES: GL checksumCalculator failure\n");
5131 }
5132 #ifdef CHECK_GL_ERRORS
5133 GLint err = this->glGetError();
5134 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGeniOES\n", err);
5135 #endif
5136 DECODER_DEBUG_LOG("gles1(%p): glTexGeniOES(coord:0x%08x pname:0x%08x param:%d )", stream, var_coord, var_pname, var_param);
5137 this->glTexGeniOES(var_coord, var_pname, var_param);
5138 SET_LASTCALL("glTexGeniOES");
5139 android::base::endTrace();
5140 break;
5141 }
5142 case OP_glTexGenivOES: {
5143 android::base::beginTrace("glTexGenivOES decode");
5144 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5145 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5146 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5147 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5148 if (useChecksum) {
5149 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5150 "gles1_decoder_context_t::decode, OP_glTexGenivOES: GL checksumCalculator failure\n");
5151 }
5152 #ifdef CHECK_GL_ERRORS
5153 GLint err = this->glGetError();
5154 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenivOES\n", err);
5155 #endif
5156 DECODER_DEBUG_LOG("gles1(%p): glTexGenivOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLint*)(inptr_params.get()), size_params);
5157 this->glTexGenivOES(var_coord, var_pname, (const GLint*)(inptr_params.get()));
5158 SET_LASTCALL("glTexGenivOES");
5159 android::base::endTrace();
5160 break;
5161 }
5162 case OP_glTexGenxOES: {
5163 android::base::beginTrace("glTexGenxOES decode");
5164 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5165 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5166 GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
5167 if (useChecksum) {
5168 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5169 "gles1_decoder_context_t::decode, OP_glTexGenxOES: GL checksumCalculator failure\n");
5170 }
5171 #ifdef CHECK_GL_ERRORS
5172 GLint err = this->glGetError();
5173 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenxOES\n", err);
5174 #endif
5175 DECODER_DEBUG_LOG("gles1(%p): glTexGenxOES(coord:0x%08x pname:0x%08x param:0x%08x )", stream, var_coord, var_pname, var_param);
5176 this->glTexGenxOES(var_coord, var_pname, var_param);
5177 SET_LASTCALL("glTexGenxOES");
5178 android::base::endTrace();
5179 break;
5180 }
5181 case OP_glTexGenxvOES: {
5182 android::base::beginTrace("glTexGenxvOES decode");
5183 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5184 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5185 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5186 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5187 if (useChecksum) {
5188 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5189 "gles1_decoder_context_t::decode, OP_glTexGenxvOES: GL checksumCalculator failure\n");
5190 }
5191 #ifdef CHECK_GL_ERRORS
5192 GLint err = this->glGetError();
5193 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenxvOES\n", err);
5194 #endif
5195 DECODER_DEBUG_LOG("gles1(%p): glTexGenxvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
5196 this->glTexGenxvOES(var_coord, var_pname, (const GLfixed*)(inptr_params.get()));
5197 SET_LASTCALL("glTexGenxvOES");
5198 android::base::endTrace();
5199 break;
5200 }
5201 case OP_glGetTexGenfvOES: {
5202 android::base::beginTrace("glGetTexGenfvOES decode");
5203 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5204 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5205 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5206 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5207 if (useChecksum) {
5208 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5209 "gles1_decoder_context_t::decode, OP_glGetTexGenfvOES: GL checksumCalculator failure\n");
5210 }
5211 #ifdef CHECK_GL_ERRORS
5212 GLint err = this->glGetError();
5213 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenfvOES\n", err);
5214 #endif
5215 DECODER_DEBUG_LOG("gles1(%p): glGetTexGenfvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLfloat*)(inptr_params.get()), size_params);
5216 this->glGetTexGenfvOES(var_coord, var_pname, (GLfloat*)(inptr_params.get()));
5217 SET_LASTCALL("glGetTexGenfvOES");
5218 android::base::endTrace();
5219 break;
5220 }
5221 case OP_glGetTexGenivOES: {
5222 android::base::beginTrace("glGetTexGenivOES decode");
5223 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5224 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5225 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5226 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5227 if (useChecksum) {
5228 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5229 "gles1_decoder_context_t::decode, OP_glGetTexGenivOES: GL checksumCalculator failure\n");
5230 }
5231 #ifdef CHECK_GL_ERRORS
5232 GLint err = this->glGetError();
5233 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenivOES\n", err);
5234 #endif
5235 DECODER_DEBUG_LOG("gles1(%p): glGetTexGenivOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLint*)(inptr_params.get()), size_params);
5236 this->glGetTexGenivOES(var_coord, var_pname, (GLint*)(inptr_params.get()));
5237 SET_LASTCALL("glGetTexGenivOES");
5238 android::base::endTrace();
5239 break;
5240 }
5241 case OP_glGetTexGenxvOES: {
5242 android::base::beginTrace("glGetTexGenxvOES decode");
5243 GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5244 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5245 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5246 InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5247 if (useChecksum) {
5248 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5249 "gles1_decoder_context_t::decode, OP_glGetTexGenxvOES: GL checksumCalculator failure\n");
5250 }
5251 #ifdef CHECK_GL_ERRORS
5252 GLint err = this->glGetError();
5253 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenxvOES\n", err);
5254 #endif
5255 DECODER_DEBUG_LOG("gles1(%p): glGetTexGenxvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLfixed*)(inptr_params.get()), size_params);
5256 this->glGetTexGenxvOES(var_coord, var_pname, (GLfixed*)(inptr_params.get()));
5257 SET_LASTCALL("glGetTexGenxvOES");
5258 android::base::endTrace();
5259 break;
5260 }
5261 case OP_glBindVertexArrayOES: {
5262 android::base::beginTrace("glBindVertexArrayOES decode");
5263 GLuint var_array = Unpack<GLuint,uint32_t>(ptr + 8);
5264 if (useChecksum) {
5265 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5266 "gles1_decoder_context_t::decode, OP_glBindVertexArrayOES: GL checksumCalculator failure\n");
5267 }
5268 #ifdef CHECK_GL_ERRORS
5269 GLint err = this->glGetError();
5270 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindVertexArrayOES\n", err);
5271 #endif
5272 DECODER_DEBUG_LOG("gles1(%p): glBindVertexArrayOES(array:%u )", stream, var_array);
5273 this->glBindVertexArrayOES(var_array);
5274 SET_LASTCALL("glBindVertexArrayOES");
5275 android::base::endTrace();
5276 break;
5277 }
5278 case OP_glDeleteVertexArraysOES: {
5279 android::base::beginTrace("glDeleteVertexArraysOES decode");
5280 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5281 uint32_t size_arrays __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5282 InputBuffer inptr_arrays(ptr + 8 + 4 + 4, size_arrays);
5283 if (useChecksum) {
5284 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_arrays, ptr + 8 + 4 + 4 + size_arrays, checksumSize,
5285 "gles1_decoder_context_t::decode, OP_glDeleteVertexArraysOES: GL checksumCalculator failure\n");
5286 }
5287 #ifdef CHECK_GL_ERRORS
5288 GLint err = this->glGetError();
5289 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteVertexArraysOES\n", err);
5290 #endif
5291 DECODER_DEBUG_LOG("gles1(%p): glDeleteVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (const GLuint*)(inptr_arrays.get()), size_arrays);
5292 this->glDeleteVertexArraysOES_dec(this, var_n, (const GLuint*)(inptr_arrays.get()));
5293 SET_LASTCALL("glDeleteVertexArraysOES");
5294 android::base::endTrace();
5295 break;
5296 }
5297 case OP_glGenVertexArraysOES: {
5298 android::base::beginTrace("glGenVertexArraysOES decode");
5299 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5300 uint32_t size_arrays __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5301 if (useChecksum) {
5302 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
5303 "gles1_decoder_context_t::decode, OP_glGenVertexArraysOES: GL checksumCalculator failure\n");
5304 }
5305 size_t totalTmpSize = size_arrays;
5306 totalTmpSize += checksumSize;
5307 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5308 OutputBuffer outptr_arrays(&tmpBuf[0], size_arrays);
5309 #ifdef CHECK_GL_ERRORS
5310 GLint err = this->glGetError();
5311 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenVertexArraysOES\n", err);
5312 #endif
5313 DECODER_DEBUG_LOG("gles1(%p): glGenVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (GLuint*)(outptr_arrays.get()), size_arrays);
5314 this->glGenVertexArraysOES_dec(this, var_n, (GLuint*)(outptr_arrays.get()));
5315 outptr_arrays.flush();
5316 if (useChecksum) {
5317 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5318 }
5319 stream->flush();
5320 SET_LASTCALL("glGenVertexArraysOES");
5321 android::base::endTrace();
5322 break;
5323 }
5324 case OP_glIsVertexArrayOES: {
5325 android::base::beginTrace("glIsVertexArrayOES decode");
5326 GLuint var_array = Unpack<GLuint,uint32_t>(ptr + 8);
5327 if (useChecksum) {
5328 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5329 "gles1_decoder_context_t::decode, OP_glIsVertexArrayOES: GL checksumCalculator failure\n");
5330 }
5331 size_t totalTmpSize = sizeof(GLboolean);
5332 totalTmpSize += checksumSize;
5333 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5334 #ifdef CHECK_GL_ERRORS
5335 GLint err = this->glGetError();
5336 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsVertexArrayOES\n", err);
5337 #endif
5338 DECODER_DEBUG_LOG("gles1(%p): glIsVertexArrayOES(array:%u )", stream, var_array);
5339 *(GLboolean *)(&tmpBuf[0]) = this->glIsVertexArrayOES(var_array);
5340 if (useChecksum) {
5341 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5342 }
5343 stream->flush();
5344 SET_LASTCALL("glIsVertexArrayOES");
5345 android::base::endTrace();
5346 break;
5347 }
5348 case OP_glDiscardFramebufferEXT: {
5349 android::base::beginTrace("glDiscardFramebufferEXT decode");
5350 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5351 GLsizei var_numAttachments = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5352 uint32_t size_attachments __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5353 InputBuffer inptr_attachments(ptr + 8 + 4 + 4 + 4, size_attachments);
5354 if (useChecksum) {
5355 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_attachments, ptr + 8 + 4 + 4 + 4 + size_attachments, checksumSize,
5356 "gles1_decoder_context_t::decode, OP_glDiscardFramebufferEXT: GL checksumCalculator failure\n");
5357 }
5358 #ifdef CHECK_GL_ERRORS
5359 GLint err = this->glGetError();
5360 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDiscardFramebufferEXT\n", err);
5361 #endif
5362 DECODER_DEBUG_LOG("gles1(%p): glDiscardFramebufferEXT(target:0x%08x numAttachments:%d attachments:%p(%u) )", stream, var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()), size_attachments);
5363 this->glDiscardFramebufferEXT(var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()));
5364 SET_LASTCALL("glDiscardFramebufferEXT");
5365 android::base::endTrace();
5366 break;
5367 }
5368 case OP_glMultiDrawArraysEXT: {
5369 android::base::beginTrace("glMultiDrawArraysEXT decode");
5370 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5371 uint32_t size_first __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5372 InputBuffer inptr_first(ptr + 8 + 4 + 4, size_first);
5373 uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_first);
5374 InputBuffer inptr_count(ptr + 8 + 4 + 4 + size_first + 4, size_count);
5375 GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_first + 4 + size_count);
5376 if (useChecksum) {
5377 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_first + 4 + size_count + 4, ptr + 8 + 4 + 4 + size_first + 4 + size_count + 4, checksumSize,
5378 "gles1_decoder_context_t::decode, OP_glMultiDrawArraysEXT: GL checksumCalculator failure\n");
5379 }
5380 #ifdef CHECK_GL_ERRORS
5381 GLint err = this->glGetError();
5382 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawArraysEXT\n", err);
5383 #endif
5384 DECODER_DEBUG_LOG("gles1(%p): glMultiDrawArraysEXT(mode:0x%08x first:%p(%u) count:%p(%u) primcount:%d )", stream, var_mode, (const GLint*)(inptr_first.get()), size_first, (const GLsizei*)(inptr_count.get()), size_count, var_primcount);
5385 this->glMultiDrawArraysEXT(var_mode, (const GLint*)(inptr_first.get()), (const GLsizei*)(inptr_count.get()), var_primcount);
5386 SET_LASTCALL("glMultiDrawArraysEXT");
5387 android::base::endTrace();
5388 break;
5389 }
5390 case OP_glMultiDrawElementsEXT: {
5391 android::base::beginTrace("glMultiDrawElementsEXT decode");
5392 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5393 uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5394 InputBuffer inptr_count(ptr + 8 + 4 + 4, size_count);
5395 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + size_count);
5396 uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4);
5397 InputBuffer inptr_indices(ptr + 8 + 4 + 4 + size_count + 4 + 4, size_indices);
5398 GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices);
5399 if (useChecksum) {
5400 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,
5401 "gles1_decoder_context_t::decode, OP_glMultiDrawElementsEXT: GL checksumCalculator failure\n");
5402 }
5403 #ifdef CHECK_GL_ERRORS
5404 GLint err = this->glGetError();
5405 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawElementsEXT\n", err);
5406 #endif
5407 DECODER_DEBUG_LOG("gles1(%p): glMultiDrawElementsEXT(mode:0x%08x count:%p(%u) type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, (const GLsizei*)(inptr_count.get()), size_count, var_type, (const GLvoid* const*)(inptr_indices.get()), size_indices, var_primcount);
5408 this->glMultiDrawElementsEXT(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid* const*)(inptr_indices.get()), var_primcount);
5409 SET_LASTCALL("glMultiDrawElementsEXT");
5410 android::base::endTrace();
5411 break;
5412 }
5413 case OP_glMultiDrawArraysSUN: {
5414 android::base::beginTrace("glMultiDrawArraysSUN decode");
5415 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5416 uint32_t size_first __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5417 InputBuffer inptr_first(ptr + 8 + 4 + 4, size_first);
5418 uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_first);
5419 InputBuffer inptr_count(ptr + 8 + 4 + 4 + size_first + 4, size_count);
5420 GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_first + 4 + size_count);
5421 if (useChecksum) {
5422 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_first + 4 + size_count + 4, ptr + 8 + 4 + 4 + size_first + 4 + size_count + 4, checksumSize,
5423 "gles1_decoder_context_t::decode, OP_glMultiDrawArraysSUN: GL checksumCalculator failure\n");
5424 }
5425 #ifdef CHECK_GL_ERRORS
5426 GLint err = this->glGetError();
5427 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawArraysSUN\n", err);
5428 #endif
5429 DECODER_DEBUG_LOG("gles1(%p): glMultiDrawArraysSUN(mode:0x%08x first:%p(%u) count:%p(%u) primcount:%d )", stream, var_mode, (GLint*)(inptr_first.get()), size_first, (GLsizei*)(inptr_count.get()), size_count, var_primcount);
5430 this->glMultiDrawArraysSUN(var_mode, (GLint*)(inptr_first.get()), (GLsizei*)(inptr_count.get()), var_primcount);
5431 SET_LASTCALL("glMultiDrawArraysSUN");
5432 android::base::endTrace();
5433 break;
5434 }
5435 case OP_glMultiDrawElementsSUN: {
5436 android::base::beginTrace("glMultiDrawElementsSUN decode");
5437 GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5438 uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5439 InputBuffer inptr_count(ptr + 8 + 4 + 4, size_count);
5440 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + size_count);
5441 uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4);
5442 InputBuffer inptr_indices(ptr + 8 + 4 + 4 + size_count + 4 + 4, size_indices);
5443 GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices);
5444 if (useChecksum) {
5445 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,
5446 "gles1_decoder_context_t::decode, OP_glMultiDrawElementsSUN: GL checksumCalculator failure\n");
5447 }
5448 #ifdef CHECK_GL_ERRORS
5449 GLint err = this->glGetError();
5450 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawElementsSUN\n", err);
5451 #endif
5452 DECODER_DEBUG_LOG("gles1(%p): glMultiDrawElementsSUN(mode:0x%08x count:%p(%u) type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, (const GLsizei*)(inptr_count.get()), size_count, var_type, (const GLvoid**)(inptr_indices.get()), size_indices, var_primcount);
5453 this->glMultiDrawElementsSUN(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid**)(inptr_indices.get()), var_primcount);
5454 SET_LASTCALL("glMultiDrawElementsSUN");
5455 android::base::endTrace();
5456 break;
5457 }
5458 case OP_glRenderbufferStorageMultisampleIMG: {
5459 android::base::beginTrace("glRenderbufferStorageMultisampleIMG decode");
5460 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5461 GLsizei var_samples = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5462 GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
5463 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
5464 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5465 if (useChecksum) {
5466 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
5467 "gles1_decoder_context_t::decode, OP_glRenderbufferStorageMultisampleIMG: GL checksumCalculator failure\n");
5468 }
5469 #ifdef CHECK_GL_ERRORS
5470 GLint err = this->glGetError();
5471 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRenderbufferStorageMultisampleIMG\n", err);
5472 #endif
5473 DECODER_DEBUG_LOG("gles1(%p): glRenderbufferStorageMultisampleIMG(target:0x%08x samples:%d internalformat:0x%08x width:%d height:%d )", stream, var_target, var_samples, var_internalformat, var_width, var_height);
5474 this->glRenderbufferStorageMultisampleIMG(var_target, var_samples, var_internalformat, var_width, var_height);
5475 SET_LASTCALL("glRenderbufferStorageMultisampleIMG");
5476 android::base::endTrace();
5477 break;
5478 }
5479 case OP_glFramebufferTexture2DMultisampleIMG: {
5480 android::base::beginTrace("glFramebufferTexture2DMultisampleIMG decode");
5481 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5482 GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5483 GLenum var_textarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
5484 GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
5485 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5486 GLsizei var_samples = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
5487 if (useChecksum) {
5488 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
5489 "gles1_decoder_context_t::decode, OP_glFramebufferTexture2DMultisampleIMG: GL checksumCalculator failure\n");
5490 }
5491 #ifdef CHECK_GL_ERRORS
5492 GLint err = this->glGetError();
5493 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferTexture2DMultisampleIMG\n", err);
5494 #endif
5495 DECODER_DEBUG_LOG("gles1(%p): glFramebufferTexture2DMultisampleIMG(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d samples:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
5496 this->glFramebufferTexture2DMultisampleIMG(var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
5497 SET_LASTCALL("glFramebufferTexture2DMultisampleIMG");
5498 android::base::endTrace();
5499 break;
5500 }
5501 case OP_glDeleteFencesNV: {
5502 android::base::beginTrace("glDeleteFencesNV decode");
5503 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5504 uint32_t size_fences __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5505 InputBuffer inptr_fences(ptr + 8 + 4 + 4, size_fences);
5506 if (useChecksum) {
5507 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
5508 "gles1_decoder_context_t::decode, OP_glDeleteFencesNV: GL checksumCalculator failure\n");
5509 }
5510 #ifdef CHECK_GL_ERRORS
5511 GLint err = this->glGetError();
5512 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteFencesNV\n", err);
5513 #endif
5514 DECODER_DEBUG_LOG("gles1(%p): glDeleteFencesNV(n:%d fences:%p(%u) )", stream, var_n, (const GLuint*)(inptr_fences.get()), size_fences);
5515 this->glDeleteFencesNV(var_n, (const GLuint*)(inptr_fences.get()));
5516 SET_LASTCALL("glDeleteFencesNV");
5517 android::base::endTrace();
5518 break;
5519 }
5520 case OP_glGenFencesNV: {
5521 android::base::beginTrace("glGenFencesNV decode");
5522 GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5523 uint32_t size_fences __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5524 InputBuffer inptr_fences(ptr + 8 + 4 + 4, size_fences);
5525 if (useChecksum) {
5526 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
5527 "gles1_decoder_context_t::decode, OP_glGenFencesNV: GL checksumCalculator failure\n");
5528 }
5529 #ifdef CHECK_GL_ERRORS
5530 GLint err = this->glGetError();
5531 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenFencesNV\n", err);
5532 #endif
5533 DECODER_DEBUG_LOG("gles1(%p): glGenFencesNV(n:%d fences:%p(%u) )", stream, var_n, (GLuint*)(inptr_fences.get()), size_fences);
5534 this->glGenFencesNV(var_n, (GLuint*)(inptr_fences.get()));
5535 SET_LASTCALL("glGenFencesNV");
5536 android::base::endTrace();
5537 break;
5538 }
5539 case OP_glIsFenceNV: {
5540 android::base::beginTrace("glIsFenceNV decode");
5541 GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5542 if (useChecksum) {
5543 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5544 "gles1_decoder_context_t::decode, OP_glIsFenceNV: GL checksumCalculator failure\n");
5545 }
5546 size_t totalTmpSize = sizeof(GLboolean);
5547 totalTmpSize += checksumSize;
5548 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5549 #ifdef CHECK_GL_ERRORS
5550 GLint err = this->glGetError();
5551 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsFenceNV\n", err);
5552 #endif
5553 DECODER_DEBUG_LOG("gles1(%p): glIsFenceNV(fence:%u )", stream, var_fence);
5554 *(GLboolean *)(&tmpBuf[0]) = this->glIsFenceNV(var_fence);
5555 if (useChecksum) {
5556 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5557 }
5558 stream->flush();
5559 SET_LASTCALL("glIsFenceNV");
5560 android::base::endTrace();
5561 break;
5562 }
5563 case OP_glTestFenceNV: {
5564 android::base::beginTrace("glTestFenceNV decode");
5565 GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5566 if (useChecksum) {
5567 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5568 "gles1_decoder_context_t::decode, OP_glTestFenceNV: GL checksumCalculator failure\n");
5569 }
5570 size_t totalTmpSize = sizeof(GLboolean);
5571 totalTmpSize += checksumSize;
5572 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5573 #ifdef CHECK_GL_ERRORS
5574 GLint err = this->glGetError();
5575 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTestFenceNV\n", err);
5576 #endif
5577 DECODER_DEBUG_LOG("gles1(%p): glTestFenceNV(fence:%u )", stream, var_fence);
5578 *(GLboolean *)(&tmpBuf[0]) = this->glTestFenceNV(var_fence);
5579 if (useChecksum) {
5580 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5581 }
5582 stream->flush();
5583 SET_LASTCALL("glTestFenceNV");
5584 android::base::endTrace();
5585 break;
5586 }
5587 case OP_glGetFenceivNV: {
5588 android::base::beginTrace("glGetFenceivNV decode");
5589 GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5590 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5591 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5592 if (useChecksum) {
5593 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5594 "gles1_decoder_context_t::decode, OP_glGetFenceivNV: GL checksumCalculator failure\n");
5595 }
5596 size_t totalTmpSize = size_params;
5597 totalTmpSize += checksumSize;
5598 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5599 OutputBuffer outptr_params(&tmpBuf[0], size_params);
5600 #ifdef CHECK_GL_ERRORS
5601 GLint err = this->glGetError();
5602 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFenceivNV\n", err);
5603 #endif
5604 DECODER_DEBUG_LOG("gles1(%p): glGetFenceivNV(fence:%u pname:0x%08x params:%p(%u) )", stream, var_fence, var_pname, (GLint*)(outptr_params.get()), size_params);
5605 this->glGetFenceivNV(var_fence, var_pname, (GLint*)(outptr_params.get()));
5606 outptr_params.flush();
5607 if (useChecksum) {
5608 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5609 }
5610 stream->flush();
5611 SET_LASTCALL("glGetFenceivNV");
5612 android::base::endTrace();
5613 break;
5614 }
5615 case OP_glFinishFenceNV: {
5616 android::base::beginTrace("glFinishFenceNV decode");
5617 GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5618 if (useChecksum) {
5619 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5620 "gles1_decoder_context_t::decode, OP_glFinishFenceNV: GL checksumCalculator failure\n");
5621 }
5622 #ifdef CHECK_GL_ERRORS
5623 GLint err = this->glGetError();
5624 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinishFenceNV\n", err);
5625 #endif
5626 DECODER_DEBUG_LOG("gles1(%p): glFinishFenceNV(fence:%u )", stream, var_fence);
5627 this->glFinishFenceNV(var_fence);
5628 SET_LASTCALL("glFinishFenceNV");
5629 android::base::endTrace();
5630 break;
5631 }
5632 case OP_glSetFenceNV: {
5633 android::base::beginTrace("glSetFenceNV decode");
5634 GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5635 GLenum var_condition = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5636 if (useChecksum) {
5637 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
5638 "gles1_decoder_context_t::decode, OP_glSetFenceNV: GL checksumCalculator failure\n");
5639 }
5640 #ifdef CHECK_GL_ERRORS
5641 GLint err = this->glGetError();
5642 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSetFenceNV\n", err);
5643 #endif
5644 DECODER_DEBUG_LOG("gles1(%p): glSetFenceNV(fence:%u condition:0x%08x )", stream, var_fence, var_condition);
5645 this->glSetFenceNV(var_fence, var_condition);
5646 SET_LASTCALL("glSetFenceNV");
5647 android::base::endTrace();
5648 break;
5649 }
5650 case OP_glGetDriverControlsQCOM: {
5651 android::base::beginTrace("glGetDriverControlsQCOM decode");
5652 uint32_t size_num __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5653 GLsizei var_size = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5654 uint32_t size_driverControls __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5655 if (useChecksum) {
5656 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5657 "gles1_decoder_context_t::decode, OP_glGetDriverControlsQCOM: GL checksumCalculator failure\n");
5658 }
5659 size_t totalTmpSize = size_num;
5660 totalTmpSize += size_driverControls;
5661 totalTmpSize += checksumSize;
5662 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5663 OutputBuffer outptr_num(&tmpBuf[0], size_num);
5664 OutputBuffer outptr_driverControls(&tmpBuf[0 + size_num], size_driverControls);
5665 #ifdef CHECK_GL_ERRORS
5666 GLint err = this->glGetError();
5667 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetDriverControlsQCOM\n", err);
5668 #endif
5669 DECODER_DEBUG_LOG("gles1(%p): glGetDriverControlsQCOM(num:%p(%u) size:%d driverControls:%p(%u) )", stream, (GLint*)(outptr_num.get()), size_num, var_size, (GLuint*)(outptr_driverControls.get()), size_driverControls);
5670 this->glGetDriverControlsQCOM((GLint*)(outptr_num.get()), var_size, (GLuint*)(outptr_driverControls.get()));
5671 outptr_num.flush();
5672 outptr_driverControls.flush();
5673 if (useChecksum) {
5674 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5675 }
5676 stream->flush();
5677 SET_LASTCALL("glGetDriverControlsQCOM");
5678 android::base::endTrace();
5679 break;
5680 }
5681 case OP_glGetDriverControlStringQCOM: {
5682 android::base::beginTrace("glGetDriverControlStringQCOM decode");
5683 GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
5684 GLsizei var_bufSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5685 uint32_t size_length __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5686 uint32_t size_driverControlString __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
5687 if (useChecksum) {
5688 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
5689 "gles1_decoder_context_t::decode, OP_glGetDriverControlStringQCOM: GL checksumCalculator failure\n");
5690 }
5691 size_t totalTmpSize = size_length;
5692 totalTmpSize += size_driverControlString;
5693 totalTmpSize += checksumSize;
5694 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5695 OutputBuffer outptr_length(&tmpBuf[0], size_length);
5696 OutputBuffer outptr_driverControlString(&tmpBuf[0 + size_length], size_driverControlString);
5697 #ifdef CHECK_GL_ERRORS
5698 GLint err = this->glGetError();
5699 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetDriverControlStringQCOM\n", err);
5700 #endif
5701 DECODER_DEBUG_LOG("gles1(%p): glGetDriverControlStringQCOM(driverControl:%u bufSize:%d length:%p(%u) driverControlString:%p(%u) )", stream, var_driverControl, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_driverControlString.get()), size_driverControlString);
5702 this->glGetDriverControlStringQCOM(var_driverControl, var_bufSize, (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_driverControlString.get()));
5703 outptr_length.flush();
5704 outptr_driverControlString.flush();
5705 if (useChecksum) {
5706 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5707 }
5708 stream->flush();
5709 SET_LASTCALL("glGetDriverControlStringQCOM");
5710 android::base::endTrace();
5711 break;
5712 }
5713 case OP_glEnableDriverControlQCOM: {
5714 android::base::beginTrace("glEnableDriverControlQCOM decode");
5715 GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
5716 if (useChecksum) {
5717 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5718 "gles1_decoder_context_t::decode, OP_glEnableDriverControlQCOM: GL checksumCalculator failure\n");
5719 }
5720 #ifdef CHECK_GL_ERRORS
5721 GLint err = this->glGetError();
5722 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnableDriverControlQCOM\n", err);
5723 #endif
5724 DECODER_DEBUG_LOG("gles1(%p): glEnableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
5725 this->glEnableDriverControlQCOM(var_driverControl);
5726 SET_LASTCALL("glEnableDriverControlQCOM");
5727 android::base::endTrace();
5728 break;
5729 }
5730 case OP_glDisableDriverControlQCOM: {
5731 android::base::beginTrace("glDisableDriverControlQCOM decode");
5732 GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
5733 if (useChecksum) {
5734 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5735 "gles1_decoder_context_t::decode, OP_glDisableDriverControlQCOM: GL checksumCalculator failure\n");
5736 }
5737 #ifdef CHECK_GL_ERRORS
5738 GLint err = this->glGetError();
5739 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisableDriverControlQCOM\n", err);
5740 #endif
5741 DECODER_DEBUG_LOG("gles1(%p): glDisableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
5742 this->glDisableDriverControlQCOM(var_driverControl);
5743 SET_LASTCALL("glDisableDriverControlQCOM");
5744 android::base::endTrace();
5745 break;
5746 }
5747 case OP_glExtGetTexturesQCOM: {
5748 android::base::beginTrace("glExtGetTexturesQCOM decode");
5749 uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5750 GLint var_maxTextures = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5751 uint32_t size_numTextures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5752 if (useChecksum) {
5753 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5754 "gles1_decoder_context_t::decode, OP_glExtGetTexturesQCOM: GL checksumCalculator failure\n");
5755 }
5756 size_t totalTmpSize = size_textures;
5757 totalTmpSize += size_numTextures;
5758 totalTmpSize += checksumSize;
5759 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5760 OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
5761 OutputBuffer outptr_numTextures(&tmpBuf[0 + size_textures], size_numTextures);
5762 #ifdef CHECK_GL_ERRORS
5763 GLint err = this->glGetError();
5764 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexturesQCOM\n", err);
5765 #endif
5766 DECODER_DEBUG_LOG("gles1(%p): glExtGetTexturesQCOM(textures:%p(%u) maxTextures:%d numTextures:%p(%u) )", stream, (GLuint*)(outptr_textures.get()), size_textures, var_maxTextures, (GLint*)(outptr_numTextures.get()), size_numTextures);
5767 this->glExtGetTexturesQCOM((GLuint*)(outptr_textures.get()), var_maxTextures, (GLint*)(outptr_numTextures.get()));
5768 outptr_textures.flush();
5769 outptr_numTextures.flush();
5770 if (useChecksum) {
5771 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5772 }
5773 stream->flush();
5774 SET_LASTCALL("glExtGetTexturesQCOM");
5775 android::base::endTrace();
5776 break;
5777 }
5778 case OP_glExtGetBuffersQCOM: {
5779 android::base::beginTrace("glExtGetBuffersQCOM decode");
5780 uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5781 GLint var_maxBuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5782 uint32_t size_numBuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5783 if (useChecksum) {
5784 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5785 "gles1_decoder_context_t::decode, OP_glExtGetBuffersQCOM: GL checksumCalculator failure\n");
5786 }
5787 size_t totalTmpSize = size_buffers;
5788 totalTmpSize += size_numBuffers;
5789 totalTmpSize += checksumSize;
5790 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5791 OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
5792 OutputBuffer outptr_numBuffers(&tmpBuf[0 + size_buffers], size_numBuffers);
5793 #ifdef CHECK_GL_ERRORS
5794 GLint err = this->glGetError();
5795 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetBuffersQCOM\n", err);
5796 #endif
5797 DECODER_DEBUG_LOG("gles1(%p): glExtGetBuffersQCOM(buffers:%p(%u) maxBuffers:%d numBuffers:%p(%u) )", stream, (GLuint*)(outptr_buffers.get()), size_buffers, var_maxBuffers, (GLint*)(outptr_numBuffers.get()), size_numBuffers);
5798 this->glExtGetBuffersQCOM((GLuint*)(outptr_buffers.get()), var_maxBuffers, (GLint*)(outptr_numBuffers.get()));
5799 outptr_buffers.flush();
5800 outptr_numBuffers.flush();
5801 if (useChecksum) {
5802 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5803 }
5804 stream->flush();
5805 SET_LASTCALL("glExtGetBuffersQCOM");
5806 android::base::endTrace();
5807 break;
5808 }
5809 case OP_glExtGetRenderbuffersQCOM: {
5810 android::base::beginTrace("glExtGetRenderbuffersQCOM decode");
5811 uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5812 GLint var_maxRenderbuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5813 uint32_t size_numRenderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5814 if (useChecksum) {
5815 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5816 "gles1_decoder_context_t::decode, OP_glExtGetRenderbuffersQCOM: GL checksumCalculator failure\n");
5817 }
5818 size_t totalTmpSize = size_renderbuffers;
5819 totalTmpSize += size_numRenderbuffers;
5820 totalTmpSize += checksumSize;
5821 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5822 OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
5823 OutputBuffer outptr_numRenderbuffers(&tmpBuf[0 + size_renderbuffers], size_numRenderbuffers);
5824 #ifdef CHECK_GL_ERRORS
5825 GLint err = this->glGetError();
5826 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetRenderbuffersQCOM\n", err);
5827 #endif
5828 DECODER_DEBUG_LOG("gles1(%p): glExtGetRenderbuffersQCOM(renderbuffers:%p(%u) maxRenderbuffers:%d numRenderbuffers:%p(%u) )", stream, (GLuint*)(outptr_renderbuffers.get()), size_renderbuffers, var_maxRenderbuffers, (GLint*)(outptr_numRenderbuffers.get()), size_numRenderbuffers);
5829 this->glExtGetRenderbuffersQCOM((GLuint*)(outptr_renderbuffers.get()), var_maxRenderbuffers, (GLint*)(outptr_numRenderbuffers.get()));
5830 outptr_renderbuffers.flush();
5831 outptr_numRenderbuffers.flush();
5832 if (useChecksum) {
5833 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5834 }
5835 stream->flush();
5836 SET_LASTCALL("glExtGetRenderbuffersQCOM");
5837 android::base::endTrace();
5838 break;
5839 }
5840 case OP_glExtGetFramebuffersQCOM: {
5841 android::base::beginTrace("glExtGetFramebuffersQCOM decode");
5842 uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5843 GLint var_maxFramebuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5844 uint32_t size_numFramebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5845 if (useChecksum) {
5846 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5847 "gles1_decoder_context_t::decode, OP_glExtGetFramebuffersQCOM: GL checksumCalculator failure\n");
5848 }
5849 size_t totalTmpSize = size_framebuffers;
5850 totalTmpSize += size_numFramebuffers;
5851 totalTmpSize += checksumSize;
5852 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5853 OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
5854 OutputBuffer outptr_numFramebuffers(&tmpBuf[0 + size_framebuffers], size_numFramebuffers);
5855 #ifdef CHECK_GL_ERRORS
5856 GLint err = this->glGetError();
5857 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetFramebuffersQCOM\n", err);
5858 #endif
5859 DECODER_DEBUG_LOG("gles1(%p): glExtGetFramebuffersQCOM(framebuffers:%p(%u) maxFramebuffers:%d numFramebuffers:%p(%u) )", stream, (GLuint*)(outptr_framebuffers.get()), size_framebuffers, var_maxFramebuffers, (GLint*)(outptr_numFramebuffers.get()), size_numFramebuffers);
5860 this->glExtGetFramebuffersQCOM((GLuint*)(outptr_framebuffers.get()), var_maxFramebuffers, (GLint*)(outptr_numFramebuffers.get()));
5861 outptr_framebuffers.flush();
5862 outptr_numFramebuffers.flush();
5863 if (useChecksum) {
5864 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5865 }
5866 stream->flush();
5867 SET_LASTCALL("glExtGetFramebuffersQCOM");
5868 android::base::endTrace();
5869 break;
5870 }
5871 case OP_glExtGetTexLevelParameterivQCOM: {
5872 android::base::beginTrace("glExtGetTexLevelParameterivQCOM decode");
5873 GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8);
5874 GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5875 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5876 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4);
5877 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5878 if (useChecksum) {
5879 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
5880 "gles1_decoder_context_t::decode, OP_glExtGetTexLevelParameterivQCOM: GL checksumCalculator failure\n");
5881 }
5882 size_t totalTmpSize = size_params;
5883 totalTmpSize += checksumSize;
5884 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5885 OutputBuffer outptr_params(&tmpBuf[0], size_params);
5886 #ifdef CHECK_GL_ERRORS
5887 GLint err = this->glGetError();
5888 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexLevelParameterivQCOM\n", err);
5889 #endif
5890 DECODER_DEBUG_LOG("gles1(%p): glExtGetTexLevelParameterivQCOM(texture:%u face:0x%08x level:%d pname:0x%08x params:%p(%u) )", stream, var_texture, var_face, var_level, var_pname, (GLint*)(outptr_params.get()), size_params);
5891 this->glExtGetTexLevelParameterivQCOM(var_texture, var_face, var_level, var_pname, (GLint*)(outptr_params.get()));
5892 outptr_params.flush();
5893 if (useChecksum) {
5894 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5895 }
5896 stream->flush();
5897 SET_LASTCALL("glExtGetTexLevelParameterivQCOM");
5898 android::base::endTrace();
5899 break;
5900 }
5901 case OP_glExtTexObjectStateOverrideiQCOM: {
5902 android::base::beginTrace("glExtTexObjectStateOverrideiQCOM decode");
5903 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5904 GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5905 GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5906 if (useChecksum) {
5907 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5908 "gles1_decoder_context_t::decode, OP_glExtTexObjectStateOverrideiQCOM: GL checksumCalculator failure\n");
5909 }
5910 #ifdef CHECK_GL_ERRORS
5911 GLint err = this->glGetError();
5912 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtTexObjectStateOverrideiQCOM\n", err);
5913 #endif
5914 DECODER_DEBUG_LOG("gles1(%p): glExtTexObjectStateOverrideiQCOM(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
5915 this->glExtTexObjectStateOverrideiQCOM(var_target, var_pname, var_param);
5916 SET_LASTCALL("glExtTexObjectStateOverrideiQCOM");
5917 android::base::endTrace();
5918 break;
5919 }
5920 case OP_glExtGetTexSubImageQCOM: {
5921 android::base::beginTrace("glExtGetTexSubImageQCOM decode");
5922 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5923 GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5924 GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5925 GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
5926 GLint var_zoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5927 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
5928 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
5929 GLsizei var_depth = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5930 GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5931 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5932 uint32_t size_texels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5933 if (useChecksum) {
5934 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,
5935 "gles1_decoder_context_t::decode, OP_glExtGetTexSubImageQCOM: GL checksumCalculator failure\n");
5936 }
5937 size_t totalTmpSize = size_texels;
5938 totalTmpSize += checksumSize;
5939 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5940 OutputBuffer outptr_texels(&tmpBuf[0], size_texels);
5941 #ifdef CHECK_GL_ERRORS
5942 GLint err = this->glGetError();
5943 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexSubImageQCOM\n", err);
5944 #endif
5945 DECODER_DEBUG_LOG("gles1(%p): glExtGetTexSubImageQCOM(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x type:0x%08x texels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (GLvoid*)(outptr_texels.get()), size_texels);
5946 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()));
5947 outptr_texels.flush();
5948 if (useChecksum) {
5949 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5950 }
5951 stream->flush();
5952 SET_LASTCALL("glExtGetTexSubImageQCOM");
5953 android::base::endTrace();
5954 break;
5955 }
5956 case OP_glExtGetBufferPointervQCOM: {
5957 android::base::beginTrace("glExtGetBufferPointervQCOM decode");
5958 GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5959 uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5960 InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
5961 if (useChecksum) {
5962 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
5963 "gles1_decoder_context_t::decode, OP_glExtGetBufferPointervQCOM: GL checksumCalculator failure\n");
5964 }
5965 #ifdef CHECK_GL_ERRORS
5966 GLint err = this->glGetError();
5967 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetBufferPointervQCOM\n", err);
5968 #endif
5969 DECODER_DEBUG_LOG("gles1(%p): glExtGetBufferPointervQCOM(target:0x%08x params:%p(%u) )", stream, var_target, (GLvoid**)(inptr_params.get()), size_params);
5970 this->glExtGetBufferPointervQCOM(var_target, (GLvoid**)(inptr_params.get()));
5971 SET_LASTCALL("glExtGetBufferPointervQCOM");
5972 android::base::endTrace();
5973 break;
5974 }
5975 case OP_glExtGetShadersQCOM: {
5976 android::base::beginTrace("glExtGetShadersQCOM decode");
5977 uint32_t size_shaders __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5978 GLint var_maxShaders = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5979 uint32_t size_numShaders __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5980 if (useChecksum) {
5981 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5982 "gles1_decoder_context_t::decode, OP_glExtGetShadersQCOM: GL checksumCalculator failure\n");
5983 }
5984 size_t totalTmpSize = size_shaders;
5985 totalTmpSize += size_numShaders;
5986 totalTmpSize += checksumSize;
5987 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5988 OutputBuffer outptr_shaders(&tmpBuf[0], size_shaders);
5989 OutputBuffer outptr_numShaders(&tmpBuf[0 + size_shaders], size_numShaders);
5990 #ifdef CHECK_GL_ERRORS
5991 GLint err = this->glGetError();
5992 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetShadersQCOM\n", err);
5993 #endif
5994 DECODER_DEBUG_LOG("gles1(%p): glExtGetShadersQCOM(shaders:%p(%u) maxShaders:%d numShaders:%p(%u) )", stream, (GLuint*)(outptr_shaders.get()), size_shaders, var_maxShaders, (GLint*)(outptr_numShaders.get()), size_numShaders);
5995 this->glExtGetShadersQCOM((GLuint*)(outptr_shaders.get()), var_maxShaders, (GLint*)(outptr_numShaders.get()));
5996 outptr_shaders.flush();
5997 outptr_numShaders.flush();
5998 if (useChecksum) {
5999 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6000 }
6001 stream->flush();
6002 SET_LASTCALL("glExtGetShadersQCOM");
6003 android::base::endTrace();
6004 break;
6005 }
6006 case OP_glExtGetProgramsQCOM: {
6007 android::base::beginTrace("glExtGetProgramsQCOM decode");
6008 uint32_t size_programs __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
6009 GLint var_maxPrograms = Unpack<GLint,uint32_t>(ptr + 8 + 4);
6010 uint32_t size_numPrograms __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
6011 if (useChecksum) {
6012 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
6013 "gles1_decoder_context_t::decode, OP_glExtGetProgramsQCOM: GL checksumCalculator failure\n");
6014 }
6015 size_t totalTmpSize = size_programs;
6016 totalTmpSize += size_numPrograms;
6017 totalTmpSize += checksumSize;
6018 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6019 OutputBuffer outptr_programs(&tmpBuf[0], size_programs);
6020 OutputBuffer outptr_numPrograms(&tmpBuf[0 + size_programs], size_numPrograms);
6021 #ifdef CHECK_GL_ERRORS
6022 GLint err = this->glGetError();
6023 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetProgramsQCOM\n", err);
6024 #endif
6025 DECODER_DEBUG_LOG("gles1(%p): glExtGetProgramsQCOM(programs:%p(%u) maxPrograms:%d numPrograms:%p(%u) )", stream, (GLuint*)(outptr_programs.get()), size_programs, var_maxPrograms, (GLint*)(outptr_numPrograms.get()), size_numPrograms);
6026 this->glExtGetProgramsQCOM((GLuint*)(outptr_programs.get()), var_maxPrograms, (GLint*)(outptr_numPrograms.get()));
6027 outptr_programs.flush();
6028 outptr_numPrograms.flush();
6029 if (useChecksum) {
6030 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6031 }
6032 stream->flush();
6033 SET_LASTCALL("glExtGetProgramsQCOM");
6034 android::base::endTrace();
6035 break;
6036 }
6037 case OP_glExtIsProgramBinaryQCOM: {
6038 android::base::beginTrace("glExtIsProgramBinaryQCOM decode");
6039 GLuint var_program = Unpack<GLuint,uint32_t>(ptr + 8);
6040 if (useChecksum) {
6041 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
6042 "gles1_decoder_context_t::decode, OP_glExtIsProgramBinaryQCOM: GL checksumCalculator failure\n");
6043 }
6044 size_t totalTmpSize = sizeof(GLboolean);
6045 totalTmpSize += checksumSize;
6046 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6047 #ifdef CHECK_GL_ERRORS
6048 GLint err = this->glGetError();
6049 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtIsProgramBinaryQCOM\n", err);
6050 #endif
6051 DECODER_DEBUG_LOG("gles1(%p): glExtIsProgramBinaryQCOM(program:%u )", stream, var_program);
6052 *(GLboolean *)(&tmpBuf[0]) = this->glExtIsProgramBinaryQCOM(var_program);
6053 if (useChecksum) {
6054 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6055 }
6056 stream->flush();
6057 SET_LASTCALL("glExtIsProgramBinaryQCOM");
6058 android::base::endTrace();
6059 break;
6060 }
6061 case OP_glExtGetProgramBinarySourceQCOM: {
6062 android::base::beginTrace("glExtGetProgramBinarySourceQCOM decode");
6063 GLuint var_program = Unpack<GLuint,uint32_t>(ptr + 8);
6064 GLenum var_shadertype = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
6065 uint32_t size_source __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
6066 InputBuffer inptr_source(ptr + 8 + 4 + 4 + 4, size_source);
6067 uint32_t size_length __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_source);
6068 InputBuffer inptr_length(ptr + 8 + 4 + 4 + 4 + size_source + 4, size_length);
6069 if (useChecksum) {
6070 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_source + 4 + size_length, ptr + 8 + 4 + 4 + 4 + size_source + 4 + size_length, checksumSize,
6071 "gles1_decoder_context_t::decode, OP_glExtGetProgramBinarySourceQCOM: GL checksumCalculator failure\n");
6072 }
6073 #ifdef CHECK_GL_ERRORS
6074 GLint err = this->glGetError();
6075 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetProgramBinarySourceQCOM\n", err);
6076 #endif
6077 DECODER_DEBUG_LOG("gles1(%p): glExtGetProgramBinarySourceQCOM(program:%u shadertype:0x%08x source:%p(%u) length:%p(%u) )", stream, var_program, var_shadertype, (GLchar*)(inptr_source.get()), size_source, (GLint*)(inptr_length.get()), size_length);
6078 this->glExtGetProgramBinarySourceQCOM(var_program, var_shadertype, (GLchar*)(inptr_source.get()), (GLint*)(inptr_length.get()));
6079 SET_LASTCALL("glExtGetProgramBinarySourceQCOM");
6080 android::base::endTrace();
6081 break;
6082 }
6083 case OP_glStartTilingQCOM: {
6084 android::base::beginTrace("glStartTilingQCOM decode");
6085 GLuint var_x = Unpack<GLuint,uint32_t>(ptr + 8);
6086 GLuint var_y = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
6087 GLuint var_width = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
6088 GLuint var_height = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
6089 GLbitfield var_preserveMask = Unpack<GLbitfield,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
6090 if (useChecksum) {
6091 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
6092 "gles1_decoder_context_t::decode, OP_glStartTilingQCOM: GL checksumCalculator failure\n");
6093 }
6094 #ifdef CHECK_GL_ERRORS
6095 GLint err = this->glGetError();
6096 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStartTilingQCOM\n", err);
6097 #endif
6098 DECODER_DEBUG_LOG("gles1(%p): glStartTilingQCOM(x:%u y:%u width:%u height:%u preserveMask:0x%08x )", stream, var_x, var_y, var_width, var_height, var_preserveMask);
6099 this->glStartTilingQCOM(var_x, var_y, var_width, var_height, var_preserveMask);
6100 SET_LASTCALL("glStartTilingQCOM");
6101 android::base::endTrace();
6102 break;
6103 }
6104 case OP_glEndTilingQCOM: {
6105 android::base::beginTrace("glEndTilingQCOM decode");
6106 GLbitfield var_preserveMask = Unpack<GLbitfield,uint32_t>(ptr + 8);
6107 if (useChecksum) {
6108 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
6109 "gles1_decoder_context_t::decode, OP_glEndTilingQCOM: GL checksumCalculator failure\n");
6110 }
6111 #ifdef CHECK_GL_ERRORS
6112 GLint err = this->glGetError();
6113 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEndTilingQCOM\n", err);
6114 #endif
6115 DECODER_DEBUG_LOG("gles1(%p): glEndTilingQCOM(preserveMask:0x%08x )", stream, var_preserveMask);
6116 this->glEndTilingQCOM(var_preserveMask);
6117 SET_LASTCALL("glEndTilingQCOM");
6118 android::base::endTrace();
6119 break;
6120 }
6121 case OP_glGetGraphicsResetStatusEXT: {
6122 android::base::beginTrace("glGetGraphicsResetStatusEXT decode");
6123 if (useChecksum) {
6124 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
6125 "gles1_decoder_context_t::decode, OP_glGetGraphicsResetStatusEXT: GL checksumCalculator failure\n");
6126 }
6127 size_t totalTmpSize = sizeof(GLenum);
6128 totalTmpSize += checksumSize;
6129 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6130 #ifdef CHECK_GL_ERRORS
6131 GLint err = this->glGetError();
6132 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetGraphicsResetStatusEXT\n", err);
6133 #endif
6134 DECODER_DEBUG_LOG("gles1(%p): glGetGraphicsResetStatusEXT()", stream);
6135 *(GLenum *)(&tmpBuf[0]) = this->glGetGraphicsResetStatusEXT();
6136 if (useChecksum) {
6137 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6138 }
6139 stream->flush();
6140 SET_LASTCALL("glGetGraphicsResetStatusEXT");
6141 android::base::endTrace();
6142 break;
6143 }
6144 case OP_glReadnPixelsEXT: {
6145 android::base::beginTrace("glReadnPixelsEXT decode");
6146 GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
6147 GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
6148 GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
6149 GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
6150 GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
6151 GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
6152 GLsizei var_bufSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
6153 uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
6154 if (useChecksum) {
6155 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
6156 "gles1_decoder_context_t::decode, OP_glReadnPixelsEXT: GL checksumCalculator failure\n");
6157 }
6158 size_t totalTmpSize = size_data;
6159 totalTmpSize += checksumSize;
6160 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6161 OutputBuffer outptr_data(&tmpBuf[0], size_data);
6162 #ifdef CHECK_GL_ERRORS
6163 GLint err = this->glGetError();
6164 if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glReadnPixelsEXT\n", err);
6165 #endif
6166 DECODER_DEBUG_LOG("gles1(%p): glReadnPixelsEXT(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x bufSize:%d data:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()), size_data);
6167 this->glReadnPixelsEXT(var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()));
6168 outptr_data.flush();
6169 if (useChecksum) {
6170 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6171 }
6172 stream->flush();
6173 SET_LASTCALL("glReadnPixelsEXT");
6174 android::base::endTrace();
6175 break;
6176 }
6177 default:
6178 return ptr - (unsigned char*)buf;
6179 } //switch
6180 #ifdef CHECK_GL_ERRORS
6181 GLint err = this->glGetError();
6182 if (err) fprintf(stderr, "gles1 Error (post-call): 0x%X in %s\n", err, lastCall);
6183 #endif
6184 ptr += packetLen;
6185 } // while
6186 return ptr - (unsigned char*)buf;
6187 }
6188 } // namespace gfxstream
6189
6190