X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;f=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fopengl%2Fsystem%2FrenderControl_enc%2FrenderControl_enc.cpp;fp=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fopengl%2Fsystem%2FrenderControl_enc%2FrenderControl_enc.cpp;h=4a22b54dab8de17fce88fe21219b476ecd6803f9;hb=e26c1ec581be598521517829adba8c8dd23a768f;hp=0000000000000000000000000000000000000000;hpb=6699c1aea74eeb0eb400e6299079f0c7576f716f;p=iec.git diff --git a/src/type3_AndroidCloud/anbox-master/android/opengl/system/renderControl_enc/renderControl_enc.cpp b/src/type3_AndroidCloud/anbox-master/android/opengl/system/renderControl_enc/renderControl_enc.cpp new file mode 100644 index 0000000..4a22b54 --- /dev/null +++ b/src/type3_AndroidCloud/anbox-master/android/opengl/system/renderControl_enc/renderControl_enc.cpp @@ -0,0 +1,1392 @@ +// Generated Code - DO NOT EDIT !! +// generated by 'emugen' + + +#include +#include +#include "renderControl_opcodes.h" + +#include "renderControl_enc.h" + + +#include + +namespace { + +void enc_unsupported() +{ + ALOGE("Function is unsupported\n"); +} + +GLint rcGetRendererVersion_enc(void *self ) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetRendererVersion;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + GLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetRendererVersion: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcGetEGLVersion_enc(void *self , EGLint* major, EGLint* minor) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_major = sizeof(EGLint); + const unsigned int __size_minor = sizeof(EGLint); + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + __size_major + __size_minor + 2*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetEGLVersion;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + *(unsigned int *)(ptr) = __size_major; ptr += 4; + *(unsigned int *)(ptr) = __size_minor; ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + stream->readback(major, __size_major); + if (useChecksum) checksumCalculator->addBuffer(major, __size_major); + stream->readback(minor, __size_minor); + if (useChecksum) checksumCalculator->addBuffer(minor, __size_minor); + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetEGLVersion: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcQueryEGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_buffer = bufferSize; + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 4 + 1*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcQueryEGLString;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &name, 4); ptr += 4; + *(unsigned int *)(ptr) = __size_buffer; ptr += 4; + memcpy(ptr, &bufferSize, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + stream->readback(buffer, __size_buffer); + if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer); + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcQueryEGLString: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcGetGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_buffer = bufferSize; + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 4 + 1*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetGLString;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &name, 4); ptr += 4; + *(unsigned int *)(ptr) = __size_buffer; ptr += 4; + memcpy(ptr, &bufferSize, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + stream->readback(buffer, __size_buffer); + if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer); + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetGLString: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcGetNumConfigs_enc(void *self , uint32_t* numAttribs) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_numAttribs = sizeof(uint32_t); + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + __size_numAttribs + 1*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetNumConfigs;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + *(unsigned int *)(ptr) = __size_numAttribs; ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + stream->readback(numAttribs, __size_numAttribs); + if (useChecksum) checksumCalculator->addBuffer(numAttribs, __size_numAttribs); + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetNumConfigs: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcGetConfigs_enc(void *self , uint32_t bufSize, GLuint* buffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_buffer = bufSize; + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetConfigs;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &bufSize, 4); ptr += 4; + *(unsigned int *)(ptr) = __size_buffer; ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + stream->readback(buffer, __size_buffer); + if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer); + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetConfigs: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcChooseConfig_enc(void *self , EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_attribs = attribs_size; + const unsigned int __size_configs = ((configs != NULL) ? configs_size*sizeof(uint32_t) : 0); + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + __size_attribs + 4 + __size_configs + 4 + 2*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcChooseConfig;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + *(unsigned int *)(ptr) = __size_attribs; ptr += 4; + memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs; + memcpy(ptr, &attribs_size, 4); ptr += 4; + *(unsigned int *)(ptr) = __size_configs; ptr += 4; + memcpy(ptr, &configs_size, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + if (configs != NULL) { + stream->readback(configs, __size_configs); + if (useChecksum) checksumCalculator->addBuffer(configs, __size_configs); + } + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcChooseConfig: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcGetFBParam_enc(void *self , EGLint param) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetFBParam;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, ¶m, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetFBParam: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +uint32_t rcCreateContext_enc(void *self , uint32_t config, uint32_t share, uint32_t glVersion) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcCreateContext;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &config, 4); ptr += 4; + memcpy(ptr, &share, 4); ptr += 4; + memcpy(ptr, &glVersion, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + uint32_t retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcCreateContext: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +void rcDestroyContext_enc(void *self , uint32_t context) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcDestroyContext;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &context, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +uint32_t rcCreateWindowSurface_enc(void *self , uint32_t config, uint32_t width, uint32_t height) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcCreateWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &config, 4); ptr += 4; + memcpy(ptr, &width, 4); ptr += 4; + memcpy(ptr, &height, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + uint32_t retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcCreateWindowSurface: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +void rcDestroyWindowSurface_enc(void *self , uint32_t windowSurface) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcDestroyWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &windowSurface, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +uint32_t rcCreateColorBuffer_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcCreateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &width, 4); ptr += 4; + memcpy(ptr, &height, 4); ptr += 4; + memcpy(ptr, &internalFormat, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + uint32_t retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcCreateColorBuffer: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +void rcOpenColorBuffer_enc(void *self , uint32_t colorbuffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcOpenColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorbuffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcCloseColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorbuffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + stream->flush(); +} + +void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcSetWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &windowSurface, 4); ptr += 4; + memcpy(ptr, &colorBuffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +int rcFlushWindowColorBuffer_enc(void *self , uint32_t windowSurface) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcFlushWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &windowSurface, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcFlushWindowColorBuffer: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +EGLint rcMakeCurrent_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcMakeCurrent;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &context, 4); ptr += 4; + memcpy(ptr, &drawSurf, 4); ptr += 4; + memcpy(ptr, &readSurf, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcMakeCurrent: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +void rcFBPost_enc(void *self , uint32_t colorBuffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcFBPost;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorBuffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +void rcFBSetSwapInterval_enc(void *self , EGLint interval) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcFBSetSwapInterval;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &interval, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +void rcBindTexture_enc(void *self , uint32_t colorBuffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcBindTexture;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorBuffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +void rcBindRenderbuffer_enc(void *self , uint32_t colorBuffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorBuffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcColorBufferCacheFlush;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorbuffer, 4); ptr += 4; + memcpy(ptr, &postCount, 4); ptr += 4; + memcpy(ptr, &forRead, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + EGLint retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcColorBufferCacheFlush: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height); + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcReadColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorbuffer, 4); ptr += 4; + memcpy(ptr, &x, 4); ptr += 4; + memcpy(ptr, &y, 4); ptr += 4; + memcpy(ptr, &width, 4); ptr += 4; + memcpy(ptr, &height, 4); ptr += 4; + memcpy(ptr, &format, 4); ptr += 4; + memcpy(ptr, &type, 4); ptr += 4; + *(unsigned int *)(ptr) = __size_pixels; ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + stream->readback(pixels, __size_pixels); + if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcReadColorBuffer: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } +} + +int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height); + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4); + ptr = buf; + int tmp = OP_rcUpdateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorbuffer, 4); ptr += 4; + memcpy(ptr, &x, 4); ptr += 4; + memcpy(ptr, &y, 4); ptr += 4; + memcpy(ptr, &width, 4); ptr += 4; + memcpy(ptr, &height, 4); ptr += 4; + memcpy(ptr, &format, 4); ptr += 4; + memcpy(ptr, &type, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + stream->flush(); + stream->writeFully(&__size_pixels,4); + if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4); + stream->writeFully(pixels, __size_pixels); + if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels); + buf = stream->alloc(checksumSize); + if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize); + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcUpdateColorBuffer: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcOpenColorBuffer2;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &colorbuffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcOpenColorBuffer2: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +uint32_t rcCreateClientImage_enc(void *self , uint32_t context, EGLenum target, GLuint buffer) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcCreateClientImage;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &context, 4); ptr += 4; + memcpy(ptr, &target, 4); ptr += 4; + memcpy(ptr, &buffer, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + uint32_t retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcCreateClientImage: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +int rcDestroyClientImage_enc(void *self , uint32_t image) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcDestroyClientImage;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &image, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcDestroyClientImage: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +void rcSelectChecksumCalculator_enc(void *self , uint32_t newProtocol, uint32_t reserved) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcSelectChecksumCalculator;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &newProtocol, 4); ptr += 4; + memcpy(ptr, &reserved, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +int rcGetNumDisplays_enc(void *self ) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetNumDisplays;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetNumDisplays: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +int rcGetDisplayWidth_enc(void *self , uint32_t displayId) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetDisplayWidth;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &displayId, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetDisplayWidth: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +int rcGetDisplayHeight_enc(void *self , uint32_t displayId) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetDisplayHeight;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &displayId, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetDisplayHeight: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +int rcGetDisplayDpiX_enc(void *self , uint32_t displayId) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetDisplayDpiX;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &displayId, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetDisplayDpiX: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +int rcGetDisplayDpiY_enc(void *self , uint32_t displayId) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetDisplayDpiY;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &displayId, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetDisplayDpiY: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +int rcGetDisplayVsyncPeriod_enc(void *self , uint32_t displayId) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + 4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcGetDisplayVsyncPeriod;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + memcpy(ptr, &displayId, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + + + int retval; + stream->readback(&retval, 4); + if (useChecksum) checksumCalculator->addBuffer(&retval, 4); + if (useChecksum) { + std::unique_ptr checksumBuf(new unsigned char[checksumSize]); + stream->readback(checksumBuf.get(), checksumSize); + if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) { + ALOGE("rcGetDisplayVsyncPeriod: GL communication error, please report this issue to b.android.com.\n"); + abort(); + } + } + return retval; +} + +void rcPostLayer_enc(void *self , const char* name, uint32_t colorBuffer, float alpha, int32_t sourceCropLeft, int32_t sourceCropTop, int32_t sourceCropRight, int32_t sourceCropBottom, int32_t displayFrameLeft, int32_t displayFrameTop, int32_t displayFrameRight, int32_t displayFrameBottom) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + const unsigned int __size_name = (strlen(name) + 1); + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8 + __size_name + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 1*4; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcPostLayer;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + *(unsigned int *)(ptr) = __size_name; ptr += 4; + memcpy(ptr, name, __size_name);ptr += __size_name; + memcpy(ptr, &colorBuffer, 4); ptr += 4; + memcpy(ptr, &alpha, 4); ptr += 4; + memcpy(ptr, &sourceCropLeft, 4); ptr += 4; + memcpy(ptr, &sourceCropTop, 4); ptr += 4; + memcpy(ptr, &sourceCropRight, 4); ptr += 4; + memcpy(ptr, &sourceCropBottom, 4); ptr += 4; + memcpy(ptr, &displayFrameLeft, 4); ptr += 4; + memcpy(ptr, &displayFrameTop, 4); ptr += 4; + memcpy(ptr, &displayFrameRight, 4); ptr += 4; + memcpy(ptr, &displayFrameBottom, 4); ptr += 4; + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +void rcPostAllLayersDone_enc(void *self ) +{ + + renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self; + IOStream *stream = ctx->m_stream; + ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator; + bool useChecksum = checksumCalculator->getVersion() > 0; + + unsigned char *ptr; + unsigned char *buf; + const size_t sizeWithoutChecksum = 8; + const size_t checksumSize = checksumCalculator->checksumByteSize(); + const size_t totalSize = sizeWithoutChecksum + checksumSize; + buf = stream->alloc(totalSize); + ptr = buf; + int tmp = OP_rcPostAllLayersDone;memcpy(ptr, &tmp, 4); ptr += 4; + memcpy(ptr, &totalSize, 4); ptr += 4; + + + if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf); + if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize; + +} + +} // namespace + +renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator) +{ + m_stream = stream; + m_checksumCalculator = checksumCalculator; + + this->rcGetRendererVersion = &rcGetRendererVersion_enc; + this->rcGetEGLVersion = &rcGetEGLVersion_enc; + this->rcQueryEGLString = &rcQueryEGLString_enc; + this->rcGetGLString = &rcGetGLString_enc; + this->rcGetNumConfigs = &rcGetNumConfigs_enc; + this->rcGetConfigs = &rcGetConfigs_enc; + this->rcChooseConfig = &rcChooseConfig_enc; + this->rcGetFBParam = &rcGetFBParam_enc; + this->rcCreateContext = &rcCreateContext_enc; + this->rcDestroyContext = &rcDestroyContext_enc; + this->rcCreateWindowSurface = &rcCreateWindowSurface_enc; + this->rcDestroyWindowSurface = &rcDestroyWindowSurface_enc; + this->rcCreateColorBuffer = &rcCreateColorBuffer_enc; + this->rcOpenColorBuffer = &rcOpenColorBuffer_enc; + this->rcCloseColorBuffer = &rcCloseColorBuffer_enc; + this->rcSetWindowColorBuffer = &rcSetWindowColorBuffer_enc; + this->rcFlushWindowColorBuffer = &rcFlushWindowColorBuffer_enc; + this->rcMakeCurrent = &rcMakeCurrent_enc; + this->rcFBPost = &rcFBPost_enc; + this->rcFBSetSwapInterval = &rcFBSetSwapInterval_enc; + this->rcBindTexture = &rcBindTexture_enc; + this->rcBindRenderbuffer = &rcBindRenderbuffer_enc; + this->rcColorBufferCacheFlush = &rcColorBufferCacheFlush_enc; + this->rcReadColorBuffer = &rcReadColorBuffer_enc; + this->rcUpdateColorBuffer = &rcUpdateColorBuffer_enc; + this->rcOpenColorBuffer2 = &rcOpenColorBuffer2_enc; + this->rcCreateClientImage = &rcCreateClientImage_enc; + this->rcDestroyClientImage = &rcDestroyClientImage_enc; + this->rcSelectChecksumCalculator = &rcSelectChecksumCalculator_enc; + this->rcGetNumDisplays = &rcGetNumDisplays_enc; + this->rcGetDisplayWidth = &rcGetDisplayWidth_enc; + this->rcGetDisplayHeight = &rcGetDisplayHeight_enc; + this->rcGetDisplayDpiX = &rcGetDisplayDpiX_enc; + this->rcGetDisplayDpiY = &rcGetDisplayDpiY_enc; + this->rcGetDisplayVsyncPeriod = &rcGetDisplayVsyncPeriod_enc; + this->rcPostLayer = &rcPostLayer_enc; + this->rcPostAllLayersDone = &rcPostAllLayersDone_enc; +} +