| // Generated Code - DO NOT EDIT !! |
| // generated by 'emugen' |
| |
| |
| #include <string.h> |
| #include "renderControl_opcodes.h" |
| |
| #include "renderControl_dec.h" |
| |
| |
| #include "ProtocolUtils.h" |
| |
| #include "ChecksumCalculatorThreadInfo.h" |
| |
| #include <stdio.h> |
| |
| typedef unsigned int tsize_t; // Target "size_t", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled. |
| |
| #ifdef CHECK_GL_ERRORS |
| # define SET_LASTCALL(name) sprintf(lastCall, #name) |
| #else |
| # define SET_LASTCALL(name) |
| #endif |
| using namespace emugl; |
| |
| size_t renderControl_decoder_context_t::decode(void *buf, size_t len, IOStream *stream, ChecksumCalculator* checksumCalc) { |
| if (len < 8) return 0; |
| #ifdef CHECK_GL_ERRORS |
| char lastCall[256] = {0}; |
| #endif |
| unsigned char *ptr = (unsigned char *)buf; |
| const unsigned char* const end = (const unsigned char*)buf + len; |
| while (end - ptr >= 8) { |
| uint32_t opcode = *(uint32_t *)ptr; |
| int32_t packetLen = *(int32_t *)(ptr + 4); |
| if (end - ptr < packetLen) return ptr - (unsigned char*)buf; |
| // Do this on every iteration, as some commands may change the checksum |
| // calculation parameters. |
| const size_t checksumSize = checksumCalc->checksumByteSize(); |
| const bool useChecksum = checksumSize > 0; |
| switch(opcode) { |
| case OP_rcGetRendererVersion: { |
| android::base::beginTrace("rcGetRendererVersion decode"); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetRendererVersion: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(GLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(GLint *)(&tmpBuf[0]) = this->rcGetRendererVersion(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetRendererVersion"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetEGLVersion: { |
| android::base::beginTrace("rcGetEGLVersion decode"); |
| uint32_t size_major __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t size_minor __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetEGLVersion: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_major; |
| totalTmpSize += size_minor; |
| totalTmpSize += sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_major(&tmpBuf[0], size_major); |
| OutputBuffer outptr_minor(&tmpBuf[0 + size_major], size_minor); |
| *(EGLint *)(&tmpBuf[0 + size_major + size_minor]) = this->rcGetEGLVersion((EGLint*)(outptr_major.get()), (EGLint*)(outptr_minor.get())); |
| outptr_major.flush(); |
| outptr_minor.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetEGLVersion"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcQueryEGLString: { |
| android::base::beginTrace("rcQueryEGLString decode"); |
| EGLenum var_name = Unpack<EGLenum,uint32_t>(ptr + 8); |
| uint32_t size_buffer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| EGLint var_bufferSize = Unpack<EGLint,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcQueryEGLString: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_buffer; |
| totalTmpSize += sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_buffer(&tmpBuf[0], size_buffer); |
| *(EGLint *)(&tmpBuf[0 + size_buffer]) = this->rcQueryEGLString(var_name, (void*)(outptr_buffer.get()), var_bufferSize); |
| outptr_buffer.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcQueryEGLString"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetGLString: { |
| android::base::beginTrace("rcGetGLString decode"); |
| EGLenum var_name = Unpack<EGLenum,uint32_t>(ptr + 8); |
| uint32_t size_buffer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| EGLint var_bufferSize = Unpack<EGLint,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetGLString: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_buffer; |
| totalTmpSize += sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_buffer(&tmpBuf[0], size_buffer); |
| *(EGLint *)(&tmpBuf[0 + size_buffer]) = this->rcGetGLString(var_name, (void*)(outptr_buffer.get()), var_bufferSize); |
| outptr_buffer.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetGLString"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetNumConfigs: { |
| android::base::beginTrace("rcGetNumConfigs decode"); |
| uint32_t size_numAttribs __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetNumConfigs: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_numAttribs; |
| totalTmpSize += sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_numAttribs(&tmpBuf[0], size_numAttribs); |
| *(EGLint *)(&tmpBuf[0 + size_numAttribs]) = this->rcGetNumConfigs((uint32_t*)(outptr_numAttribs.get())); |
| outptr_numAttribs.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetNumConfigs"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetConfigs: { |
| android::base::beginTrace("rcGetConfigs decode"); |
| uint32_t var_bufSize = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t size_buffer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetConfigs: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_buffer; |
| totalTmpSize += sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_buffer(&tmpBuf[0], size_buffer); |
| *(EGLint *)(&tmpBuf[0 + size_buffer]) = this->rcGetConfigs(var_bufSize, (GLuint*)(outptr_buffer.get())); |
| outptr_buffer.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetConfigs"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcChooseConfig: { |
| android::base::beginTrace("rcChooseConfig decode"); |
| uint32_t size_attribs __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8); |
| InputBuffer inptr_attribs(ptr + 8 + 4, size_attribs); |
| uint32_t var_attribs_size = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + size_attribs); |
| uint32_t size_configs __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + size_attribs + 4); |
| uint32_t var_configs_size = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + size_attribs + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_attribs + 4 + 4 + 4, ptr + 8 + 4 + size_attribs + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcChooseConfig: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_configs; |
| totalTmpSize += sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_configs(&tmpBuf[0], size_configs); |
| *(EGLint *)(&tmpBuf[0 + size_configs]) = this->rcChooseConfig((EGLint*)(inptr_attribs.get()), var_attribs_size, size_configs == 0 ? nullptr : (uint32_t*)(outptr_configs.get()), var_configs_size); |
| outptr_configs.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcChooseConfig"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetFBParam: { |
| android::base::beginTrace("rcGetFBParam decode"); |
| EGLint var_param = Unpack<EGLint,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetFBParam: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(EGLint *)(&tmpBuf[0]) = this->rcGetFBParam(var_param); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetFBParam"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateContext: { |
| android::base::beginTrace("rcCreateContext decode"); |
| uint32_t var_config = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_share = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| uint32_t var_glVersion = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateContext: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(uint32_t); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(uint32_t *)(&tmpBuf[0]) = this->rcCreateContext(var_config, var_share, var_glVersion); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateContext"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcDestroyContext: { |
| android::base::beginTrace("rcDestroyContext decode"); |
| uint32_t var_context = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcDestroyContext: GL checksumCalculator failure\n"); |
| } |
| this->rcDestroyContext(var_context); |
| SET_LASTCALL("rcDestroyContext"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateWindowSurface: { |
| android::base::beginTrace("rcCreateWindowSurface decode"); |
| uint32_t var_config = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_width = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| uint32_t var_height = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateWindowSurface: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(uint32_t); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(uint32_t *)(&tmpBuf[0]) = this->rcCreateWindowSurface(var_config, var_width, var_height); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateWindowSurface"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcDestroyWindowSurface: { |
| android::base::beginTrace("rcDestroyWindowSurface decode"); |
| uint32_t var_windowSurface = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcDestroyWindowSurface: GL checksumCalculator failure\n"); |
| } |
| this->rcDestroyWindowSurface(var_windowSurface); |
| SET_LASTCALL("rcDestroyWindowSurface"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateColorBuffer: { |
| android::base::beginTrace("rcCreateColorBuffer decode"); |
| uint32_t var_width = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_height = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| GLenum var_internalFormat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateColorBuffer: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(uint32_t); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(uint32_t *)(&tmpBuf[0]) = this->rcCreateColorBuffer(var_width, var_height, var_internalFormat); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcOpenColorBuffer: { |
| android::base::beginTrace("rcOpenColorBuffer decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcOpenColorBuffer: GL checksumCalculator failure\n"); |
| } |
| this->rcOpenColorBuffer(var_colorbuffer); |
| SET_LASTCALL("rcOpenColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCloseColorBuffer: { |
| android::base::beginTrace("rcCloseColorBuffer decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCloseColorBuffer: GL checksumCalculator failure\n"); |
| } |
| this->rcCloseColorBuffer(var_colorbuffer); |
| SET_LASTCALL("rcCloseColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSetWindowColorBuffer: { |
| android::base::beginTrace("rcSetWindowColorBuffer decode"); |
| uint32_t var_windowSurface = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSetWindowColorBuffer: GL checksumCalculator failure\n"); |
| } |
| this->rcSetWindowColorBuffer(var_windowSurface, var_colorBuffer); |
| SET_LASTCALL("rcSetWindowColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcFlushWindowColorBuffer: { |
| android::base::beginTrace("rcFlushWindowColorBuffer decode"); |
| uint32_t var_windowSurface = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcFlushWindowColorBuffer: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcFlushWindowColorBuffer(var_windowSurface); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcFlushWindowColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcMakeCurrent: { |
| android::base::beginTrace("rcMakeCurrent decode"); |
| uint32_t var_context = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_drawSurf = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| uint32_t var_readSurf = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcMakeCurrent: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(EGLint *)(&tmpBuf[0]) = this->rcMakeCurrent(var_context, var_drawSurf, var_readSurf); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcMakeCurrent"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcFBPost: { |
| android::base::beginTrace("rcFBPost decode"); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcFBPost: GL checksumCalculator failure\n"); |
| } |
| this->rcFBPost(var_colorBuffer); |
| SET_LASTCALL("rcFBPost"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcFBSetSwapInterval: { |
| android::base::beginTrace("rcFBSetSwapInterval decode"); |
| EGLint var_interval = Unpack<EGLint,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcFBSetSwapInterval: GL checksumCalculator failure\n"); |
| } |
| this->rcFBSetSwapInterval(var_interval); |
| SET_LASTCALL("rcFBSetSwapInterval"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcBindTexture: { |
| android::base::beginTrace("rcBindTexture decode"); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcBindTexture: GL checksumCalculator failure\n"); |
| } |
| this->rcBindTexture(var_colorBuffer); |
| SET_LASTCALL("rcBindTexture"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcBindRenderbuffer: { |
| android::base::beginTrace("rcBindRenderbuffer decode"); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcBindRenderbuffer: GL checksumCalculator failure\n"); |
| } |
| this->rcBindRenderbuffer(var_colorBuffer); |
| SET_LASTCALL("rcBindRenderbuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcColorBufferCacheFlush: { |
| android::base::beginTrace("rcColorBufferCacheFlush decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| EGLint var_postCount = Unpack<EGLint,uint32_t>(ptr + 8 + 4); |
| int var_forRead = Unpack<int,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcColorBufferCacheFlush: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(EGLint *)(&tmpBuf[0]) = this->rcColorBufferCacheFlush(var_colorbuffer, var_postCount, var_forRead); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcColorBufferCacheFlush"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcReadColorBuffer: { |
| android::base::beginTrace("rcReadColorBuffer decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4); |
| GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4); |
| GLint var_width = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| GLint var_height = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4); |
| GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4); |
| GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4); |
| uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcReadColorBuffer: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_pixels; |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels); |
| this->rcReadColorBuffer(var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, (void*)(outptr_pixels.get())); |
| outptr_pixels.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcReadColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcUpdateColorBuffer: { |
| android::base::beginTrace("rcUpdateColorBuffer decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4); |
| GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4); |
| GLint var_width = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| GLint var_height = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4); |
| GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4); |
| GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4); |
| uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4); |
| InputBuffer inptr_pixels(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_pixels); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcUpdateColorBuffer: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcUpdateColorBuffer(var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, (void*)(inptr_pixels.get())); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcUpdateColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcOpenColorBuffer2: { |
| android::base::beginTrace("rcOpenColorBuffer2 decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcOpenColorBuffer2: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcOpenColorBuffer2(var_colorbuffer); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcOpenColorBuffer2"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateClientImage: { |
| android::base::beginTrace("rcCreateClientImage decode"); |
| uint32_t var_context = Unpack<uint32_t,uint32_t>(ptr + 8); |
| EGLenum var_target = Unpack<EGLenum,uint32_t>(ptr + 8 + 4); |
| GLuint var_buffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateClientImage: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(uint32_t); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(uint32_t *)(&tmpBuf[0]) = this->rcCreateClientImage(var_context, var_target, var_buffer); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateClientImage"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcDestroyClientImage: { |
| android::base::beginTrace("rcDestroyClientImage decode"); |
| uint32_t var_image = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcDestroyClientImage: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcDestroyClientImage(var_image); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcDestroyClientImage"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSelectChecksumHelper: { |
| android::base::beginTrace("rcSelectChecksumHelper decode"); |
| uint32_t var_newProtocol = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_reserved = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSelectChecksumHelper: GL checksumCalculator failure\n"); |
| } |
| this->rcSelectChecksumHelper(var_newProtocol, var_reserved); |
| SET_LASTCALL("rcSelectChecksumHelper"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateSyncKHR: { |
| android::base::beginTrace("rcCreateSyncKHR decode"); |
| EGLenum var_type = Unpack<EGLenum,uint32_t>(ptr + 8); |
| uint32_t size_attribs __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| InputBuffer inptr_attribs(ptr + 8 + 4 + 4, size_attribs); |
| uint32_t var_num_attribs = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_attribs); |
| int var_destroy_when_signaled = Unpack<int,uint32_t>(ptr + 8 + 4 + 4 + size_attribs + 4); |
| uint32_t size_glsync_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_attribs + 4 + 4); |
| uint32_t size_syncthread_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_attribs + 4 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_attribs + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + size_attribs + 4 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateSyncKHR: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_glsync_out; |
| totalTmpSize += size_syncthread_out; |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_glsync_out(&tmpBuf[0], size_glsync_out); |
| OutputBuffer outptr_syncthread_out(&tmpBuf[0 + size_glsync_out], size_syncthread_out); |
| this->rcCreateSyncKHR(var_type, (EGLint*)(inptr_attribs.get()), var_num_attribs, var_destroy_when_signaled, (uint64_t*)(outptr_glsync_out.get()), (uint64_t*)(outptr_syncthread_out.get())); |
| outptr_glsync_out.flush(); |
| outptr_syncthread_out.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateSyncKHR"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcClientWaitSyncKHR: { |
| android::base::beginTrace("rcClientWaitSyncKHR decode"); |
| uint64_t var_sync = Unpack<uint64_t,uint64_t>(ptr + 8); |
| EGLint var_flags = Unpack<EGLint,uint32_t>(ptr + 8 + 8); |
| uint64_t var_timeout = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8, ptr + 8 + 8 + 4 + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcClientWaitSyncKHR: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(EGLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(EGLint *)(&tmpBuf[0]) = this->rcClientWaitSyncKHR(var_sync, var_flags, var_timeout); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcClientWaitSyncKHR"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcFlushWindowColorBufferAsync: { |
| android::base::beginTrace("rcFlushWindowColorBufferAsync decode"); |
| uint32_t var_windowSurface = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcFlushWindowColorBufferAsync: GL checksumCalculator failure\n"); |
| } |
| this->rcFlushWindowColorBufferAsync(var_windowSurface); |
| SET_LASTCALL("rcFlushWindowColorBufferAsync"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcDestroySyncKHR: { |
| android::base::beginTrace("rcDestroySyncKHR decode"); |
| uint64_t var_sync = Unpack<uint64_t,uint64_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcDestroySyncKHR: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcDestroySyncKHR(var_sync); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcDestroySyncKHR"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSetPuid: { |
| android::base::beginTrace("rcSetPuid decode"); |
| uint64_t var_puid = Unpack<uint64_t,uint64_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSetPuid: GL checksumCalculator failure\n"); |
| } |
| this->rcSetPuid(var_puid); |
| SET_LASTCALL("rcSetPuid"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcUpdateColorBufferDMA: { |
| android::base::beginTrace("rcUpdateColorBufferDMA decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4); |
| GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4); |
| GLint var_width = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| GLint var_height = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4); |
| GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4); |
| GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4); |
| uint64_t var_pixels_guest_paddr = Unpack<uint64_t,uint64_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4); |
| void* var_pixels = stream->getDmaForReading(var_pixels_guest_paddr); |
| uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8); |
| uint32_t var_pixels_size = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcUpdateColorBufferDMA: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcUpdateColorBufferDMA(var_colorbuffer, var_x, var_y, var_width, var_height, var_format, var_type, var_pixels, var_pixels_size); |
| stream->unlockDma(var_pixels_guest_paddr); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcUpdateColorBufferDMA"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateColorBufferDMA: { |
| android::base::beginTrace("rcCreateColorBufferDMA decode"); |
| uint32_t var_width = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_height = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| GLenum var_internalFormat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4); |
| int var_frameworkFormat = Unpack<int,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateColorBufferDMA: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(uint32_t); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(uint32_t *)(&tmpBuf[0]) = this->rcCreateColorBufferDMA(var_width, var_height, var_internalFormat, var_frameworkFormat); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateColorBufferDMA"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcWaitSyncKHR: { |
| android::base::beginTrace("rcWaitSyncKHR decode"); |
| uint64_t var_sync = Unpack<uint64_t,uint64_t>(ptr + 8); |
| EGLint var_flags = Unpack<EGLint,uint32_t>(ptr + 8 + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcWaitSyncKHR: GL checksumCalculator failure\n"); |
| } |
| this->rcWaitSyncKHR(var_sync, var_flags); |
| SET_LASTCALL("rcWaitSyncKHR"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCompose: { |
| android::base::beginTrace("rcCompose decode"); |
| uint32_t var_bufferSize = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t size_buffer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| InputBuffer inptr_buffer(ptr + 8 + 4 + 4, size_buffer); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_buffer, ptr + 8 + 4 + 4 + size_buffer, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCompose: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(GLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(GLint *)(&tmpBuf[0]) = this->rcCompose(var_bufferSize, (void*)(inptr_buffer.get())); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCompose"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateDisplay: { |
| android::base::beginTrace("rcCreateDisplay decode"); |
| uint32_t size_displayId __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateDisplay: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_displayId; |
| totalTmpSize += sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_displayId(&tmpBuf[0], size_displayId); |
| *(int *)(&tmpBuf[0 + size_displayId]) = this->rcCreateDisplay((uint32_t*)(outptr_displayId.get())); |
| outptr_displayId.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateDisplay"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcDestroyDisplay: { |
| android::base::beginTrace("rcDestroyDisplay decode"); |
| uint32_t var_displayId = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcDestroyDisplay: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcDestroyDisplay(var_displayId); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcDestroyDisplay"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSetDisplayColorBuffer: { |
| android::base::beginTrace("rcSetDisplayColorBuffer decode"); |
| uint32_t var_displayId = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSetDisplayColorBuffer: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcSetDisplayColorBuffer(var_displayId, var_colorBuffer); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcSetDisplayColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetDisplayColorBuffer: { |
| android::base::beginTrace("rcGetDisplayColorBuffer decode"); |
| uint32_t var_displayId = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t size_colorBuffer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetDisplayColorBuffer: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_colorBuffer; |
| totalTmpSize += sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_colorBuffer(&tmpBuf[0], size_colorBuffer); |
| *(int *)(&tmpBuf[0 + size_colorBuffer]) = this->rcGetDisplayColorBuffer(var_displayId, (uint32_t*)(outptr_colorBuffer.get())); |
| outptr_colorBuffer.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetDisplayColorBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetColorBufferDisplay: { |
| android::base::beginTrace("rcGetColorBufferDisplay decode"); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t size_displayId __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetColorBufferDisplay: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_displayId; |
| totalTmpSize += sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_displayId(&tmpBuf[0], size_displayId); |
| *(int *)(&tmpBuf[0 + size_displayId]) = this->rcGetColorBufferDisplay(var_colorBuffer, (uint32_t*)(outptr_displayId.get())); |
| outptr_displayId.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetColorBufferDisplay"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcGetDisplayPose: { |
| android::base::beginTrace("rcGetDisplayPose decode"); |
| uint32_t var_displayId = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t size_x __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| uint32_t size_y __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4); |
| uint32_t size_w __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| uint32_t size_h __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcGetDisplayPose: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_x; |
| totalTmpSize += size_y; |
| totalTmpSize += size_w; |
| totalTmpSize += size_h; |
| totalTmpSize += sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_x(&tmpBuf[0], size_x); |
| OutputBuffer outptr_y(&tmpBuf[0 + size_x], size_y); |
| OutputBuffer outptr_w(&tmpBuf[0 + size_x + size_y], size_w); |
| OutputBuffer outptr_h(&tmpBuf[0 + size_x + size_y + size_w], size_h); |
| *(int *)(&tmpBuf[0 + size_x + size_y + size_w + size_h]) = this->rcGetDisplayPose(var_displayId, (GLint*)(outptr_x.get()), (GLint*)(outptr_y.get()), (uint32_t*)(outptr_w.get()), (uint32_t*)(outptr_h.get())); |
| outptr_x.flush(); |
| outptr_y.flush(); |
| outptr_w.flush(); |
| outptr_h.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcGetDisplayPose"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSetDisplayPose: { |
| android::base::beginTrace("rcSetDisplayPose decode"); |
| uint32_t var_displayId = Unpack<uint32_t,uint32_t>(ptr + 8); |
| GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4); |
| GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4); |
| uint32_t var_w = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| uint32_t var_h = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSetDisplayPose: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcSetDisplayPose(var_displayId, var_x, var_y, var_w, var_h); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcSetDisplayPose"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSetColorBufferVulkanMode: { |
| android::base::beginTrace("rcSetColorBufferVulkanMode decode"); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_mode = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSetColorBufferVulkanMode: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(GLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(GLint *)(&tmpBuf[0]) = this->rcSetColorBufferVulkanMode(var_colorBuffer, var_mode); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcSetColorBufferVulkanMode"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcReadColorBufferYUV: { |
| android::base::beginTrace("rcReadColorBufferYUV decode"); |
| uint32_t var_colorbuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4); |
| GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4); |
| GLint var_width = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| GLint var_height = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4); |
| uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4); |
| uint32_t var_pixels_size = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcReadColorBufferYUV: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = size_pixels; |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels); |
| this->rcReadColorBufferYUV(var_colorbuffer, var_x, var_y, var_width, var_height, (void*)(outptr_pixels.get()), var_pixels_size); |
| outptr_pixels.flush(); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcReadColorBufferYUV"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcIsSyncSignaled: { |
| android::base::beginTrace("rcIsSyncSignaled decode"); |
| uint64_t var_sync = Unpack<uint64_t,uint64_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcIsSyncSignaled: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcIsSyncSignaled(var_sync); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcIsSyncSignaled"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateColorBufferWithHandle: { |
| android::base::beginTrace("rcCreateColorBufferWithHandle decode"); |
| uint32_t var_width = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_height = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| GLenum var_internalFormat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4); |
| uint32_t var_handle = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateColorBufferWithHandle: GL checksumCalculator failure\n"); |
| } |
| this->rcCreateColorBufferWithHandle(var_width, var_height, var_internalFormat, var_handle); |
| SET_LASTCALL("rcCreateColorBufferWithHandle"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateBuffer: { |
| android::base::beginTrace("rcCreateBuffer decode"); |
| uint32_t var_size = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateBuffer: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(uint32_t); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(uint32_t *)(&tmpBuf[0]) = this->rcCreateBuffer(var_size); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCloseBuffer: { |
| android::base::beginTrace("rcCloseBuffer decode"); |
| uint32_t var_buffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCloseBuffer: GL checksumCalculator failure\n"); |
| } |
| this->rcCloseBuffer(var_buffer); |
| SET_LASTCALL("rcCloseBuffer"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSetColorBufferVulkanMode2: { |
| android::base::beginTrace("rcSetColorBufferVulkanMode2 decode"); |
| uint32_t var_colorBuffer = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_mode = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| uint32_t var_memoryProperty = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSetColorBufferVulkanMode2: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(GLint); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(GLint *)(&tmpBuf[0]) = this->rcSetColorBufferVulkanMode2(var_colorBuffer, var_mode, var_memoryProperty); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcSetColorBufferVulkanMode2"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcMapGpaToBufferHandle: { |
| android::base::beginTrace("rcMapGpaToBufferHandle decode"); |
| uint32_t var_bufferHandle = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint64_t var_gpa = Unpack<uint64_t,uint64_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 8, ptr + 8 + 4 + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcMapGpaToBufferHandle: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcMapGpaToBufferHandle(var_bufferHandle, var_gpa); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcMapGpaToBufferHandle"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcCreateBuffer2: { |
| android::base::beginTrace("rcCreateBuffer2 decode"); |
| uint64_t var_size = Unpack<uint64_t,uint64_t>(ptr + 8); |
| uint32_t var_memoryProperty = Unpack<uint32_t,uint32_t>(ptr + 8 + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcCreateBuffer2: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(uint32_t); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(uint32_t *)(&tmpBuf[0]) = this->rcCreateBuffer2(var_size, var_memoryProperty); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcCreateBuffer2"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcMapGpaToBufferHandle2: { |
| android::base::beginTrace("rcMapGpaToBufferHandle2 decode"); |
| uint32_t var_bufferHandle = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint64_t var_gpa = Unpack<uint64_t,uint64_t>(ptr + 8 + 4); |
| uint64_t var_size = Unpack<uint64_t,uint64_t>(ptr + 8 + 4 + 8); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 8 + 8, ptr + 8 + 4 + 8 + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcMapGpaToBufferHandle2: GL checksumCalculator failure\n"); |
| } |
| size_t totalTmpSize = sizeof(int); |
| totalTmpSize += checksumSize; |
| unsigned char *tmpBuf = stream->alloc(totalTmpSize); |
| *(int *)(&tmpBuf[0]) = this->rcMapGpaToBufferHandle2(var_bufferHandle, var_gpa, var_size); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize); |
| } |
| stream->flush(); |
| SET_LASTCALL("rcMapGpaToBufferHandle2"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcFlushWindowColorBufferAsyncWithFrameNumber: { |
| android::base::beginTrace("rcFlushWindowColorBufferAsyncWithFrameNumber decode"); |
| uint32_t var_windowSurface = Unpack<uint32_t,uint32_t>(ptr + 8); |
| uint32_t var_frameNumber = Unpack<uint32_t,uint32_t>(ptr + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcFlushWindowColorBufferAsyncWithFrameNumber: GL checksumCalculator failure\n"); |
| } |
| this->rcFlushWindowColorBufferAsyncWithFrameNumber(var_windowSurface, var_frameNumber); |
| SET_LASTCALL("rcFlushWindowColorBufferAsyncWithFrameNumber"); |
| android::base::endTrace(); |
| break; |
| } |
| case OP_rcSetTracingForPuid: { |
| android::base::beginTrace("rcSetTracingForPuid decode"); |
| uint64_t var_puid = Unpack<uint64_t,uint64_t>(ptr + 8); |
| uint32_t var_enable = Unpack<uint32_t,uint32_t>(ptr + 8 + 8); |
| uint64_t var_guestTime = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4); |
| if (useChecksum) { |
| ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8, ptr + 8 + 8 + 4 + 8, checksumSize, |
| "renderControl_decoder_context_t::decode, OP_rcSetTracingForPuid: GL checksumCalculator failure\n"); |
| } |
| this->rcSetTracingForPuid(var_puid, var_enable, var_guestTime); |
| SET_LASTCALL("rcSetTracingForPuid"); |
| android::base::endTrace(); |
| break; |
| } |
| default: |
| return ptr - (unsigned char*)buf; |
| } //switch |
| ptr += packetLen; |
| } // while |
| return ptr - (unsigned char*)buf; |
| } |
