Java tutorial
/* ** Copyright 2011, The Android Open Source Project ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** ** http://www.apache.org/licenses/LICENSE-2.0 ** ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ package com.android.glesv2debugger; import com.android.glesv2debugger.DebuggerMessage.Message; import com.android.glesv2debugger.DebuggerMessage.Message.Function; import com.android.sdklib.util.SparseIntArray; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jface.dialogs.ProgressMonitorDialog; import org.eclipse.jface.operation.IRunnableWithProgress; import org.eclipse.swt.widgets.Shell; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import java.lang.reflect.InvocationTargetException; import java.nio.ByteBuffer; public class CodeGen implements IRunnableWithProgress { private FileWriter codeFile, makeFile, namesHeaderFile, namesSourceFile; private PrintWriter code, make, namesHeader, namesSource; private FileOutputStream dataOut; private SparseIntArray bufferNames, framebufferNames, programNames, textureNames, shaderNames, renderbufferNames; /** return true if msg was a texture upload */ private boolean codeGenTextureUpload(final Message msg, final boolean replaceCopy) { String s = null; switch (msg.getFunction()) { case glCompressedTexImage2D: s = MessageFormatter.format(msg, true).replace("arg7", "texData"); break; case glCompressedTexSubImage2D: case glTexImage2D: case glTexSubImage2D: s = MessageFormatter.format(msg, true).replace("arg8", "texData"); break; case glCopyTexImage2D: if (!replaceCopy) { code.write(MessageFormatter.format(msg, true)); code.write(";CHKERR;\n"); return true; } assert msg.getArg2() == msg.getPixelFormat(); // TODO s = "//" + MessageFormatter.format(msg, true) + "\n"; s += String.format("glTexImage2D(%s, %d, %s, %d, %d, %d, %s, %s, texData);CHKERR;", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), GLEnum.valueOf(msg.getArg2()), msg.getArg5(), msg.getArg6(), msg.getArg7(), GLEnum.valueOf(msg.getPixelFormat()), GLEnum.valueOf(msg.getPixelType())); break; case glCopyTexSubImage2D: if (!replaceCopy) { code.write(MessageFormatter.format(msg, true)); code.write(";CHKERR;\n"); return true; } // FIXME: check the texture format & type, and convert s = "//" + MessageFormatter.format(msg, true) + "\n"; s += String.format("glTexSubImage2D(%s, %d, %d, %d, %d, %d, %s, %s, texData);CHKERR;", GLEnum.valueOf(msg.getArg0()), msg.getArg1(), msg.getArg2(), msg.getArg3(), msg.getArg6(), msg.getArg7(), GLEnum.valueOf(msg.getPixelFormat()), GLEnum.valueOf(msg.getPixelType())); break; default: return false; } if (msg.hasData()) { final byte[] data = MessageProcessor.lzfDecompressChunks(msg.getData()); try { code.write("{\n"); code.format(" void * texData = malloc(%d);CHKERR;\n", data.length); code.format(" FILE * texFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n"); code.format(" assert(texFile);CHKERR;\n"); code.format(" fseek(texFile, %d, SEEK_SET);CHKERR;\n", dataOut.getChannel().position()); dataOut.write(data); code.format(" fread(texData, %d, 1, texFile);CHKERR;\n", data.length); code.format(" fclose(texFile);CHKERR;\n"); code.format(" " + s + ";\n"); code.format(" free(texData);CHKERR;\n"); code.format("}\n"); } catch (IOException e) { e.printStackTrace(); assert false; } } else code.write(s.replace("texData", "NULL") + ";\n"); return true; } private void codeGenServerState(final GLServerState serverState) { code.write("// CodeGenServerState\n"); for (int i = 0; i < serverState.enableDisables.size(); i++) { final GLEnum key = GLEnum.valueOf(serverState.enableDisables.keyAt(i)); if (serverState.enableDisables.valueAt(i) == 0) code.format("glDisable(%s);CHKERR;\n", key); else code.format("glEnable(%s);CHKERR;\n", key); } for (int i = 0; i < serverState.lastSetter.size(); i++) { final Function key = Function.valueOf(serverState.lastSetter.keyAt(i)); final Message msg = serverState.lastSetter.valueAt(i); if (msg == null) { code.format("// %s is default\n", key); continue; } final String s = MessageFormatter.format(msg, true); code.write(s); code.write(";\n"); } // TODO: stencil and integers } private void codeGenServerShader(final GLServerShader serverShader) { code.write("// CodeGenServerShader\n"); for (int i = 0; i < serverShader.shaders.size(); i++) { final int name = serverShader.shaders.keyAt(i); final GLShader shader = serverShader.shaders.valueAt(i); final String id = "shader_" + name; if (shaderNames.indexOfKey(name) < 0) { namesSource.format("GLuint %s = 0;\n", id); namesHeader.format("extern GLuint %s;\n", id); } code.format("%s = glCreateShader(%s);CHKERR;\n", id, shader.type); shaderNames.put(name, name); if (shader.source != null) { final String src = shader.source.replace("\r", "").replace("\n", "\\n\\\n").replace("\"", "\\\""); code.format("glShaderSource(%s, 1, (const GLchar *[]){\"%s\"}, NULL);CHKERR;\n", id, src); code.format("glCompileShader(%s);CHKERR;\n", id); } } for (int i = 0; i < serverShader.programs.size(); i++) { final int name = serverShader.programs.keyAt(i); final GLProgram program = serverShader.programs.valueAt(i); final String id = "program_" + name; if (programNames.indexOfKey(name) < 0) { namesSource.format("GLuint %s = 0;\n", id); namesHeader.format("extern GLuint %s;\n", id); } code.format("%s = glCreateProgram();CHKERR;\n", id); programNames.put(name, name); code.format("glAttachShader(%s, shader_%d);CHKERR;\n", id, program.vert); code.format("glAttachShader(%s, shader_%d);CHKERR;\n", id, program.frag); code.format("glLinkProgram(%s);CHKERR;\n", id); if (serverShader.current == program) code.format("glUseProgram(%s);CHKERR;\n", id); } } private void codeGenServerTexture(final GLServerTexture serverTexture, final boolean replaceCopy) { code.write("// CodeGenServerTexture\n"); for (int i = 0; i < serverTexture.textures.size(); i++) { final int name = serverTexture.textures.keyAt(i); final GLTexture tex = serverTexture.textures.valueAt(i); final String id = "texture_" + name; if (textureNames.indexOfKey(name) < 0) { namesHeader.format("extern GLuint %s;\n", id); namesSource.format("GLuint %s = 0;\n", id); } code.format("%s = 0;\n", id); textureNames.put(name, name); if (name == 0) continue; code.format("glGenTextures(1, &%s);CHKERR;\n", id); String s = String.format("glBindTexture(%s, texture_%d);CHKERR;\n", tex.target, tex.name); code.write(s); for (final Message msg : tex.contentChanges) { if (codeGenTextureUpload(msg, replaceCopy)) continue; switch (msg.getFunction()) { case glGenerateMipmap: s = MessageFormatter.format(msg, true); break; default: assert false; } code.write(s + ";\n"); } code.format("glTexParameteriv(%s, GL_TEXTURE_WRAP_S, (GLint[]){%s});CHKERR;\n", tex.target, tex.wrapS); code.format("glTexParameteriv(%s, GL_TEXTURE_WRAP_T, (GLint[]){%s});CHKERR;\n", tex.target, tex.wrapT); code.format("glTexParameteriv(%s, GL_TEXTURE_MIN_FILTER, (GLint[]){%s});CHKERR;\n", tex.target, tex.min); code.format("glTexParameteriv(%s, GL_TEXTURE_MAG_FILTER, (GLint[]){%s});CHKERR;\n", tex.target, tex.mag); } for (int i = 0; i < serverTexture.tmu2D.length; i++) { code.format("glActiveTexture(%s);CHKERR;\n", GLEnum.valueOf(GLEnum.GL_TEXTURE0.value + i)); code.format("glBindTexture(GL_TEXTURE_2D, texture_%d);CHKERR;\n", serverTexture.tmu2D[i]); } for (int i = 0; i < serverTexture.tmuCube.length; i++) { code.format("glActiveTexture(%s);CHKERR;\n", GLEnum.valueOf(GLEnum.GL_TEXTURE0.value + i)); code.format("glBindTexture(GL_TEXTURE_CUBE_MAP, texture_%d);CHKERR;\n", serverTexture.tmuCube[i]); } code.format("glActiveTexture(%s);CHKERR;\n", serverTexture.activeTexture); if (serverTexture.tex2D == null) code.format("glBindTexture(GL_TEXTURE_2D, 0);CHKERR;\n"); else code.format("glBindTexture(GL_TEXTURE_2D, texture_%d);CHKERR;\n", serverTexture.tex2D.name); if (serverTexture.texCube == null) code.format("glBindTexture(GL_TEXTURE_CUBE_MAP, 0);CHKERR;\n"); else code.format("glBindTexture(GL_TEXTURE_CUBE_MAP, texture_%d);CHKERR;\n", serverTexture.texCube.name); } private void codeGenBufferData(final ByteBuffer buffer, final String call) { ByteBuffer bfr = buffer; if (buffer.isReadOnly()) { bfr = ByteBuffer.allocate(buffer.capacity()); bfr.put(buffer); } final byte[] data = bfr.array(); try { code.write("{\n"); code.format(" void * bufferData = malloc(%d);\n", data.length); code.format(" FILE * bufferFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");\n"); code.format(" assert(bufferFile);\n"); code.format(" fseek(bufferFile, %d, SEEK_SET);\n", dataOut.getChannel().position()); dataOut.write(data); code.format(" fread(bufferData, %d, 1, bufferFile);\n", data.length); code.format(" fclose(bufferFile);\n"); code.format(" " + call + ";CHKERR;\n"); code.format(" free(bufferData);\n"); code.format("}\n"); } catch (IOException e) { e.printStackTrace(); assert false; } } private void codeGenServerVertex(final GLServerVertex v) { code.write("// CodeGenServerVertex\n"); for (int i = 0; i < v.buffers.size(); i++) { final int name = v.buffers.keyAt(i); final String id = "buffer_" + name; final GLBuffer buffer = v.buffers.valueAt(i); if (bufferNames.indexOfKey(name) < 0) { namesHeader.format("extern GLuint %s;\n", id); namesSource.format("GLuint %s = 0;\n", id); } code.format("%s = 0;\n", id); bufferNames.put(name, name); if (name == 0) continue; code.format("glGenBuffers(1, &%s);CHKERR;\n", id); if (buffer.target != null) { code.format("glBindBuffer(%s, %s);CHKERR;\n", buffer.target, id); if (buffer.data != null) { String s = String.format("glBufferData(%s, %d, bufferData, %s)", buffer.target, buffer.data.capacity(), buffer.usage); codeGenBufferData(buffer.data, s); } } } // TODO: use MAX_VERTEX_ATTRIBS for (int i = 0; i < v.defaultAttribs.length; i++) code.format("glVertexAttrib4f(%d, %f, %f, %f, %f);CHKERR;\n", i, v.defaultAttribs[i][0], v.defaultAttribs[i][1], v.defaultAttribs[i][2], v.defaultAttribs[i][3]); for (int i = 0; i < v.attribPointers.length; i++) { final GLAttribPointer att = v.attribPointers[i]; if (att.type == null) continue; if (att.buffer != null) code.format("glBindBuffer(GL_ARRAY_BUFFER, buffer_%d);CHKERR;\n", att.buffer.name); else code.format("glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n"); code.format("glVertexAttribPointer(%d, %d, %s, %b, %d, (const GLvoid *)%d);CHKERR;\n", i, att.size, att.type, att.normalized, att.stride, att.ptr); } if (v.attribBuffer != null) code.format("glBindBuffer(GL_ARRAY_BUFFER, buffer_%d);CHKERR;\n", v.attribBuffer.name); else code.write("glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n"); if (v.indexBuffer != null) code.format("glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer_%d);CHKERR;\n", v.indexBuffer.name); else code.write("glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);CHKERR;\n"); } private void codeGenGenNames(final Message msg) { final ByteBuffer names = msg.getData().asReadOnlyByteBuffer(); names.order(SampleView.targetByteOrder); SparseIntArray namesArray = null; for (int i = 0; i < msg.getArg0(); i++) { String id = ""; final int name = names.getInt(); switch (msg.getFunction()) { case glGenBuffers: id = "buffer"; namesArray = bufferNames; break; case glGenFramebuffers: id = "framebuffer"; namesArray = framebufferNames; break; case glGenRenderbuffers: id = "renderbuffer"; namesArray = renderbufferNames; break; case glGenTextures: id = "texture"; namesArray = textureNames; break; default: assert false; } id += "_" + name; if (namesArray.indexOfKey(name) < 0) { namesHeader.format("extern GLuint %s;\n", id); namesSource.format("GLuint %s = 0;\n", id); } code.format("%s = 0;\n", id); namesArray.put(name, name); code.format("%s(1, &%s);CHKERR;\n", msg.getFunction(), id); } } private void codeGenDeleteNames(final Message msg) { final ByteBuffer names = msg.getData().asReadOnlyByteBuffer(); names.order(SampleView.targetByteOrder); SparseIntArray namesArray = null; for (int i = 0; i < msg.getArg0(); i++) { String id = null; final int name = names.getInt(); switch (msg.getFunction()) { case glDeleteBuffers: id = "buffer"; namesArray = bufferNames; break; case glDeleteFramebuffers: id = "framebuffer"; namesArray = framebufferNames; break; case glDeleteRenderbuffers: id = "renderbuffer"; namesArray = renderbufferNames; break; case glDeleteTextures: id = "texture"; namesArray = textureNames; break; default: assert false; } id += "_" + name; code.format("%s = 0;\n", id); namesArray.put(name, 0); code.format("%s(1, &%s);CHKERR;\n", msg.getFunction(), id); } } private void codeGenBindNames(final Message msg) { String id = null; SparseIntArray namesArray = null; final int name = msg.getArg1(); switch (msg.getFunction()) { case glBindBuffer: id = "buffer"; namesArray = bufferNames; break; case glBindFramebuffer: id = "framebuffer"; namesArray = framebufferNames; break; case glBindRenderbuffer: id = "renderbuffer"; namesArray = renderbufferNames; break; case glBindTexture: id = "texture"; namesArray = textureNames; break; default: assert false; } id += "_" + name; if (namesArray.indexOfKey(name) < 0) { namesHeader.format("extern GLuint %s;\n", id); namesSource.format("GLuint %s = 0;\n", id); } else if (namesArray.get(name) != name) code.format("%s = %d;\n", id, name); // name was deleted namesArray.put(name, name); code.write(MessageFormatter.format(msg, true)); code.write(";CHKERR;\n"); } private void codeGenDrawArrays(final GLServerVertex v, final MessageData msgData) throws IOException { final int maxAttrib = msgData.msg.getArg7(); if (maxAttrib < 1) { code.write("// no vertex data\n"); return; } final byte[] data = msgData.msg.getData().toByteArray(); final GLEnum mode = GLEnum.valueOf(msgData.msg.getArg0()); final int first = msgData.msg.getArg1(), count = msgData.msg.getArg2(); int attribDataStride = 0; for (int i = 0; i < maxAttrib; i++) { final GLAttribPointer att = v.attribPointers[i]; if (!att.enabled) continue; if (att.buffer != null) continue; attribDataStride += att.elemSize; } assert attribDataStride * count == data.length; code.write("{\n"); if (attribDataStride > 0) { code.format(" FILE * attribFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n"); code.format(" assert(attribFile);CHKERR;\n"); code.format(" fseek(attribFile, %d, SEEK_SET);CHKERR;\n", dataOut.getChannel().position()); dataOut.write(data); code.format(" char * const attribData = (char *)malloc(%d);\n", first * attribDataStride + data.length); code.format(" assert(attribData);\n"); code.format(" fread(attribData + %d, %d, 1, attribFile);\n", first * attribDataStride, data.length); code.format(" fclose(attribFile);\n"); code.format(" glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n"); int attribDataOffset = 0; for (int i = 0; i < maxAttrib; i++) { final GLAttribPointer att = v.attribPointers[i]; if (!att.enabled) continue; if (att.buffer != null) continue; code.format(" glVertexAttribPointer(%d, %d, %s, %b, %d, attribData + %d);CHKERR;\n", i, att.size, att.type, att.normalized, attribDataStride, attribDataOffset); attribDataOffset += att.elemSize; } if (v.attribBuffer != null) code.format(" glBindBuffer(GL_ARRAY_BUFFER, %d);CHKERR;\n", v.attribBuffer.name); } code.format(" glDrawArrays(%s, %d, %d);CHKERR;\n", mode, first, count); if (attribDataStride > 0) code.format(" free(attribData);CHKERR;\n"); code.write("};\n"); } private void codeGenDrawElements(final GLServerVertex v, final MessageData msgData) throws IOException { final int maxAttrib = msgData.msg.getArg7(); if (maxAttrib < 1) { code.write("// no vertex data\n"); return; } final GLEnum mode = GLEnum.valueOf(msgData.msg.getArg0()); final int count = msgData.msg.getArg1(); final GLEnum type = GLEnum.valueOf(msgData.msg.getArg2()); String typeName = "GLubyte"; if (type == GLEnum.GL_UNSIGNED_SHORT) typeName = "GLushort"; int attribDataStride = 0; for (int i = 0; i < maxAttrib; i++) { final GLAttribPointer att = v.attribPointers[i]; if (!att.enabled) continue; if (att.buffer != null) continue; attribDataStride += att.elemSize; } code.write("{\n"); if (v.indexBuffer == null || attribDataStride > 0) { // need to load user pointer indices and/or attributes final byte[] element = new byte[attribDataStride]; final ByteBuffer data = msgData.msg.getData().asReadOnlyByteBuffer(); data.order(SampleView.targetByteOrder); final ByteBuffer indexData = ByteBuffer.allocate(count * GLServerVertex.typeSize(type)); indexData.order(SampleView.targetByteOrder); final ByteBuffer attribData = ByteBuffer.allocate(count * attribDataStride); attribData.order(SampleView.targetByteOrder); int maxIndex = -1; ByteBuffer indexSrc = data; if (v.indexBuffer != null) { indexSrc = v.indexBuffer.data; indexSrc.position(msgData.msg.getArg3()); } indexSrc.order(SampleView.targetByteOrder); for (int i = 0; i < count; i++) { int index = -1; if (type == GLEnum.GL_UNSIGNED_BYTE) { byte idx = indexSrc.get(); index = idx & 0xff; indexData.put(idx); } else if (type == GLEnum.GL_UNSIGNED_SHORT) { short idx = indexSrc.getShort(); index = idx & 0xffff; indexData.putShort(idx); } else assert false; data.get(element); attribData.put(element); if (index > maxIndex) maxIndex = index; } code.format(" FILE * attribFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n"); code.format(" assert(attribFile);CHKERR;\n"); code.format(" fseek(attribFile, 0x%X, SEEK_SET);CHKERR;\n", dataOut.getChannel().position()); dataOut.write(indexData.array()); code.format(" %s * const indexData = (%s *)malloc(%d);\n", typeName, typeName, indexData.capacity()); code.format(" assert(indexData);\n"); code.format(" fread(indexData, %d, 1, attribFile);\n", indexData.capacity()); if (attribDataStride > 0) { code.format(" glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n"); for (int i = 0; i < maxAttrib; i++) { final GLAttribPointer att = v.attribPointers[i]; if (!att.enabled) continue; if (att.buffer != null) continue; code.format(" char * const attrib%d = (char *)malloc(%d);\n", i, att.elemSize * (maxIndex + 1)); code.format(" assert(attrib%d);\n", i); code.format(" glVertexAttribPointer(%d, %d, %s, %b, %d, attrib%d);CHKERR;\n", i, att.size, att.type, att.normalized, att.elemSize, i); } dataOut.write(attribData.array()); code.format(" for (%s i = 0; i < %d; i++) {\n", typeName, count); for (int i = 0; i < maxAttrib; i++) { final GLAttribPointer att = v.attribPointers[i]; if (!att.enabled) continue; if (att.buffer != null) continue; code.format(" fread(attrib%d + indexData[i] * %d, %d, 1, attribFile);\n", i, att.elemSize, att.elemSize); } code.format(" }\n"); if (v.attribBuffer != null) code.format(" glBindBuffer(GL_ARRAY_BUFFER, %d);CHKERR;\n", v.attribBuffer.name); } code.format(" fclose(attribFile);\n"); } if (v.indexBuffer != null) code.format(" glDrawElements(%s, %d, %s, (const void *)%d);CHKERR;\n", mode, count, type, msgData.msg.getArg3()); else { code.format(" glDrawElements(%s, %d, %s, indexData);CHKERR;\n", mode, count, type); code.format(" free(indexData);\n"); } for (int i = 0; i < maxAttrib; i++) { final GLAttribPointer att = v.attribPointers[i]; if (!att.enabled) continue; if (att.buffer != null) continue; code.format(" free(attrib%d);\n", i); } code.write("};\n"); } private void codeGenDraw(final GLServerVertex v, final MessageData msgData) throws IOException { final int maxAttrib = msgData.msg.getArg7(); if (maxAttrib < 1) { code.write("// no vertex data\n"); return; } final int count = msgData.attribs[0].length / 4; final GLEnum mode = GLEnum.valueOf(msgData.msg.getArg0()); final ByteBuffer attribData = ByteBuffer.allocate(maxAttrib * count * 16); attribData.order(SampleView.targetByteOrder); for (int i = 0; i < count; i++) for (int j = 0; j < maxAttrib; j++) for (int k = 0; k < 4; k++) attribData.putFloat(msgData.attribs[j][i * 4 + k]); assert attribData.remaining() == 0; code.write("{\n"); code.format(" FILE * attribFile = fopen(\"/sdcard/frame_data.bin\", \"rb\");CHKERR;\n"); code.format(" assert(attribFile);CHKERR;\n"); code.format(" fseek(attribFile, 0x%X, SEEK_SET);CHKERR;\n", dataOut.getChannel().position()); dataOut.write(attribData.array()); code.format(" char * const attribData = (char *)malloc(%d);\n", attribData.capacity()); code.format(" assert(attribData);\n"); code.format(" fread(attribData, %d, 1, attribFile);\n", attribData.capacity()); code.format(" fclose(attribFile);\n"); code.format(" glBindBuffer(GL_ARRAY_BUFFER, 0);CHKERR;\n"); for (int i = 0; i < maxAttrib; i++) { final GLAttribPointer att = v.attribPointers[i]; assert msgData.attribs[i].length == count * 4; code.format(" glVertexAttribPointer(%d, %d, GL_FLOAT, GL_FALSE, %d, attribData + %d);CHKERR;\n", i, att.size, maxAttrib * 16, i * 16); } code.format(" glDrawArrays(%s, 0, %d);CHKERR;\n", mode, count); code.format(" free(attribData);\n"); if (v.attribBuffer != null) code.format(" glBindBuffer(GL_ARRAY_BUFFER, %d);CHKERR;\n", v.attribBuffer.name); code.write("};\n"); } private void codeGenFunction(final Context ctx, final MessageData msgData) throws IOException { final Message msg = msgData.msg; String call = MessageFormatter.format(msg, true); switch (msg.getFunction()) { case glActiveTexture: case glAttachShader: case glBindAttribLocation: break; case glBindBuffer: case glBindFramebuffer: case glBindRenderbuffer: case glBindTexture: codeGenBindNames(msg); return; case glBlendColor: case glBlendEquation: case glBlendEquationSeparate: case glBlendFunc: case glBlendFuncSeparate: break; case glBufferData: call = MessageFormatter.format(msg, true).replace("arg2", "bufferData"); codeGenBufferData(msg.getData().asReadOnlyByteBuffer(), call); return; case glBufferSubData: call = MessageFormatter.format(msg, true).replace("arg3", "bufferData"); codeGenBufferData(msg.getData().asReadOnlyByteBuffer(), call); return; case glCheckFramebufferStatus: case glClear: case glClearColor: case glClearDepthf: case glClearStencil: case glColorMask: case glCompileShader: break; case glCompressedTexImage2D: case glCompressedTexSubImage2D: case glCopyTexImage2D: case glCopyTexSubImage2D: codeGenTextureUpload(msg, false); return; case glCreateProgram: namesHeader.format("extern GLuint program_%d;\n", msg.getRet()); namesSource.format("GLuint program_%d = 0;\n", msg.getRet()); code.format("program_%d = glCreateProgram();CHKERR;\n", msg.getRet()); return; case glCreateShader: namesHeader.format("extern GLuint shader_%d;\n", msg.getRet()); namesSource.format("GLuint shader_%d = 0;\n", msg.getRet()); code.format("shader_%d = %s;\n", msg.getRet(), call); return; case glCullFace: break; case glDeleteBuffers: case glDeleteFramebuffers: case glDeleteProgram: programNames.put(msg.getArg0(), 0); break; case glDeleteRenderbuffers: codeGenDeleteNames(msg); return; case glDeleteShader: shaderNames.put(msg.getArg0(), 0); return; case glDeleteTextures: codeGenDeleteNames(msg); return; case glDepthFunc: case glDepthMask: case glDepthRangef: case glDetachShader: case glDisable: case glDisableVertexAttribArray: break; case glDrawArrays: // CodeGenDraw(ctx.serverVertex, msgData); codeGenDrawArrays(ctx.serverVertex, msgData); return; case glDrawElements: // CodeGenDraw(ctx.serverVertex, msgData); codeGenDrawElements(ctx.serverVertex, msgData); return; case glEnable: case glEnableVertexAttribArray: case glFinish: case glFlush: case glFramebufferRenderbuffer: case glFramebufferTexture2D: case glFrontFace: break; case glGenBuffers: codeGenGenNames(msg); return; case glGenerateMipmap: break; case glGenFramebuffers: case glGenRenderbuffers: case glGenTextures: codeGenGenNames(msg); return; case glGetActiveAttrib: case glGetActiveUniform: case glGetAttachedShaders: break; case glGetAttribLocation: call = String.format("assert(%d == %s)", msg.getRet(), call); break; case glGetBooleanv: case glGetBufferParameteriv: return; // TODO case glGetError: code.write("CHKERR;\n"); return; case glGetFloatv: case glGetFramebufferAttachmentParameteriv: case glGetIntegerv: case glGetProgramiv: case glGetProgramInfoLog: case glGetRenderbufferParameteriv: case glGetShaderiv: case glGetShaderInfoLog: case glGetShaderPrecisionFormat: case glGetShaderSource: case glGetString: case glGetTexParameterfv: case glGetTexParameteriv: case glGetUniformfv: case glGetUniformiv: return; case glGetUniformLocation: call = String.format("assert(%d == %s)", msg.getRet(), call); break; case glGetVertexAttribfv: case glGetVertexAttribiv: case glGetVertexAttribPointerv: return; // TODO case glHint: case glIsBuffer: case glIsEnabled: case glIsFramebuffer: case glIsProgram: case glIsRenderbuffer: case glIsShader: case glIsTexture: case glLineWidth: case glLinkProgram: case glPixelStorei: case glPolygonOffset: break; case glReadPixels: return; // TODO case glReleaseShaderCompiler: case glRenderbufferStorage: case glSampleCoverage: case glScissor: break; case glShaderBinary: return; // TODO case glShaderSource: call = String.format("glShaderSource(shader_%d, 1, (const char * []){\"%s\"}, NULL)", msg.getArg0(), msg.getData().toStringUtf8().replace("\r", "").replace("\n", "\\n\\\n").replace("\"", "\\\"")); break; case glStencilFunc: case glStencilFuncSeparate: case glStencilMask: case glStencilMaskSeparate: case glStencilOp: case glStencilOpSeparate: break; case glTexImage2D: codeGenTextureUpload(msg, false); return; case glTexParameterf: break; case glTexParameterfv: return; // TODO case glTexParameteri: break; case glTexParameteriv: return; // TODO case glTexSubImage2D: codeGenTextureUpload(msg, false); return; case glUniform1f: case glUniform1fv: case glUniform1i: case glUniform1iv: case glUniform2f: case glUniform2fv: case glUniform2i: case glUniform2iv: case glUniform3f: case glUniform3fv: case glUniform3i: case glUniform3iv: case glUniform4f: case glUniform4fv: case glUniform4i: case glUniform4iv: case glUniformMatrix2fv: case glUniformMatrix3fv: case glUniformMatrix4fv: case glUseProgram: case glValidateProgram: case glVertexAttrib1f: case glVertexAttrib1fv: case glVertexAttrib2f: case glVertexAttrib2fv: case glVertexAttrib3f: case glVertexAttrib3fv: case glVertexAttrib4f: case glVertexAttrib4fv: break; case glVertexAttribPointer: // if it's user pointer, then CodeGenDrawArrays/Elements will // replace it with loaded data just before the draw call = call.replace("arg5", "(const void *)0x" + Integer.toHexString(msg.getArg5())); break; case glViewport: break; case eglSwapBuffers: return; default: assert false; return; } if (call.indexOf("glEnable(/*cap*/ GL_TEXTURE_2D)") >= 0) return; else if (call.indexOf("glDisable(/*cap*/ GL_TEXTURE_2D)") >= 0) return; else if (call.indexOf("glActiveTexture(/*texture*/ GL_TEXTURE_2D)") >= 0) return; code.write(call + ";CHKERR;\n"); } private void codeGenSetup(final Context ctx) { try { codeFile = new FileWriter("frame_setup.cpp", false); code = new PrintWriter(codeFile); dataOut = new FileOutputStream("frame_data.bin", false); namesHeaderFile = new FileWriter("frame_names.h", false); namesHeader = new PrintWriter(namesHeaderFile); namesSourceFile = new FileWriter("frame_names.cpp", false); namesSource = new PrintWriter(namesSourceFile); } catch (IOException e) { e.printStackTrace(); assert false; } bufferNames = new SparseIntArray(); framebufferNames = new SparseIntArray(); programNames = new SparseIntArray(); textureNames = new SparseIntArray(); shaderNames = new SparseIntArray(); renderbufferNames = new SparseIntArray(); namesHeader.write("#include <stdlib.h>\n"); namesHeader.write("#include <stdio.h>\n"); namesHeader.write("#include <assert.h>\n"); namesHeader.write("#include <GLES2/gl2.h>\n"); namesHeader.write("#include <GLES2/gl2ext.h>\n"); namesHeader.write("#define CHKERR assert(GL_NO_ERROR == glGetError());/**/\n"); namesHeader.write("void FrameSetup();\n"); namesHeader.write("extern const unsigned int FrameCount;\n"); namesHeader.write("extern const GLuint program_0;\n"); namesSource.write("/*\n" + " * Copyright (C) 2011 The Android Open Source Project\n" + " *\n" + " * Licensed under the Apache License, Version 2.0 (the \"License\");\n" + " * you may not use this file except in compliance with the License.\n" + " * You may obtain a copy of the License at\n" + " *\n" + " * http://www.apache.org/licenses/LICENSE-2.0\n" + " *\n" + " * Unless required by applicable law or agreed to in writing, software\n" + " * distributed under the License is distributed on an \"AS IS\" BASIS,\n" + " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" + " * See the License for the specific language governing permissions and\n" + " * limitations under the License.\n" + " */\n" + "\n" + "#include <stdlib.h>\n" + "#include <stdio.h>\n" + "\n" + "#include <EGL/egl.h>\n" + "#include <GLES2/gl2.h>\n" + "#include <GLES2/gl2ext.h>\n" + "\n" + "#include <ui/FramebufferNativeWindow.h>\n" + "#include <ui/EGLUtils.h>\n" + "\n" + "#include <private/ui/android_natives_priv.h>\n" + "\n" + "#include <surfaceflinger/Surface.h>\n" + "#include <surfaceflinger/ISurface.h>\n" + "#include <surfaceflinger/SurfaceComposerClient.h>\n" + "\n" + "using namespace android;\n" + "\n" + "static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE)\n" + "{\n" + " if (returnVal != EGL_TRUE) {\n" + " fprintf(stderr, \"%s() returned %d\\n\", op, returnVal);\n" + " }\n" + "\n" + " for (EGLint error = eglGetError(); error != EGL_SUCCESS; error\n" + " = eglGetError()) {\n" + " fprintf(stderr, \"after %s() eglError %s (0x%x)\\n\", op, EGLUtils::strerror(error),\n" + " error);\n" + " }\n" + "}\n" + "\n" + "static EGLDisplay dpy;\n" + "static EGLSurface surface;\n" + "\n" + "#include \"frame_names.h\"\n" + "const GLuint program_0 = 0;\n" + "int main(int argc, char** argv)\n" + "{\n" + " EGLBoolean returnValue;\n" + " EGLConfig myConfig = {0};\n" + "\n" + " EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };\n" + " EGLint majorVersion;\n" + " EGLint minorVersion;\n" + " EGLContext context;\n" + " EGLint w, h;\n" + "\n" + "\n" + " checkEglError(\"<init>\");\n" + " dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);\n" + " checkEglError(\"eglGetDisplay\");\n" + " if (dpy == EGL_NO_DISPLAY) {\n" + " printf(\"eglGetDisplay returned EGL_NO_DISPLAY.\\n\");\n" + " return 0;\n" + " }\n" + "\n" + " returnValue = eglInitialize(dpy, &majorVersion, &minorVersion);\n" + " checkEglError(\"eglInitialize\", returnValue);\n" + " if (returnValue != EGL_TRUE) {\n" + " printf(\"eglInitialize failed\\n\");\n" + " return 0;\n" + " }\n" + "\n" + " sp<SurfaceComposerClient> spClient;\n" + " sp<SurfaceControl> spControl;\n" + " sp<Surface> spSurface;\n" + "\n" + " // create a client to surfaceflinger\n" + " spClient = new SurfaceComposerClient();\n" + "\n" + " spControl = spClient->createSurface(getpid(), 0, 1280, 752, PIXEL_FORMAT_RGBX_8888);\n" + " spClient->openTransaction();\n" + " spControl->setLayer(350000);\n" + " spControl->show();\n" + " spClient->closeTransaction();\n" + "\n" + " spSurface = spControl->getSurface();\n" + " EGLNativeWindowType window = spSurface.get();\n" + "\n" + " printf(\"window=%p\\n\", window);\n" + " EGLint attrib_list[] = {\n" + " EGL_SURFACE_TYPE, EGL_WINDOW_BIT,\n" + " EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,\n" + " EGL_BUFFER_SIZE, 32,\n" + " EGL_RED_SIZE, 8,\n" + " EGL_GREEN_SIZE, 8,\n" + " EGL_BLUE_SIZE, 8,\n" + " EGL_NONE\n" + " };\n" + "\n" + " EGLConfig configs[12] = {0};\n" + " int num_config = -1;\n" + " eglChooseConfig(dpy, attrib_list, configs, sizeof(configs) / sizeof(*configs), &num_config);\n" + " printf(\"eglChooseConfig %d \\n\", num_config);\n" + "\n" + " surface = eglCreateWindowSurface(dpy, configs[0], window, NULL);\n" + " checkEglError(\"eglCreateWindowSurface\");\n" + " if (surface == EGL_NO_SURFACE) {\n" + " printf(\"gelCreateWindowSurface failed.\\n\");\n" + " return 0;\n" + " }\n" + "\n" + " context = eglCreateContext(dpy, configs[0], EGL_NO_CONTEXT, context_attribs);\n" + " checkEglError(\"eglCreateContext\");\n" + " if (context == EGL_NO_CONTEXT) {\n" + " printf(\"eglCreateContext failed\\n\");\n" + " return 0;\n" + " }\n" + " printf(\"context=%p \\n\", context);\n" + "\n" + " returnValue = eglMakeCurrent(dpy, surface, surface, context);\n" + " checkEglError(\"eglMakeCurrent\", returnValue);\n" + " if (returnValue != EGL_TRUE) {\n" + " return 0;\n" + " }\n" + "\n" + " glClearColor(1,1,1,1);\n" + " glClear(GL_COLOR_BUFFER_BIT);\n" + "\n" + " FrameSetup();\n" + " while (true)\n" + " for (unsigned int i = 0; i < FrameCount; i++) {\n" + " Frames[i]();\n" + " eglSwapBuffers(dpy, surface);\n" + " printf(\"press ENTER after Frame%d \\n\", i);\n" + " getchar();\n" + " }\n" + "\n" + " return 0;\n" + "}"); code.write("#include \"frame_names.h\"\n"); code.write("void FrameSetup(){\n"); codeGenServerState(ctx.serverState); codeGenServerShader(ctx.serverShader); codeGenServerTexture(ctx.serverTexture, true); codeGenServerVertex(ctx.serverVertex); code.write("}\n"); try { codeFile.close(); makeFile = new FileWriter("Android.mk", false); make = new PrintWriter(makeFile); make.write("LOCAL_PATH:= $(call my-dir)\n" + "include $(CLEAR_VARS)\n" + "LOCAL_SRC_FILES := \\\n"); } catch (IOException e) { e.printStackTrace(); assert false; } } private void codeGenCleanup() { make.write(" frame_setup.cpp \\\n"); make.write(" frame_names.cpp \\\n"); make.write("#\n"); make.write("LOCAL_SHARED_LIBRARIES := \\\n" + " libcutils \\\n" + " libutils \\\n" + " libEGL \\\n" + " libGLESv2 \\\n" + " libui \\\n" + " libhardware \\\n" + " libgui\n" + "\n" + "LOCAL_MODULE:= gles2dbg\n" + "\n" + "LOCAL_MODULE_TAGS := optional\n" + "\n" + "LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -O0 -g -DDEBUG -UNDEBUG\n" + "\n" + "include $(BUILD_EXECUTABLE)"); try { dataOut.flush(); dataOut.close(); codeFile.close(); makeFile.close(); namesHeaderFile.close(); namesSourceFile.close(); } catch (IOException e) { e.printStackTrace(); assert false; } dataOut = null; code = null; codeFile = null; make = null; makeFile = null; bufferNames = null; framebufferNames = null; programNames = null; textureNames = null; shaderNames = null; renderbufferNames = null; } private DebugContext dbgCtx; private int count; private IProgressMonitor progress; @Override public void run(IProgressMonitor monitor) { progress.beginTask("CodeGenFrames", count + 2); Context ctx = dbgCtx.getFrame(0).startContext.clone(); codeGenSetup(ctx); progress.worked(1); for (int i = 0; i < count; i++) { try { codeFile = new FileWriter("frame" + i + ".cpp", false); code = new PrintWriter(codeFile); } catch (IOException e1) { e1.printStackTrace(); assert false; } make.format(" frame%d.cpp \\\n", i); code.write("#include \"frame_names.h\"\n"); code.format("void Frame%d(){\n", i); final Frame frame = dbgCtx.getFrame(i); for (int j = 0; j < frame.size(); j++) { final MessageData msgData = frame.get(j); code.format("/* frame function %d: %s %s*/\n", j, msgData.msg.getFunction(), MessageFormatter.format(msgData.msg, false)); ctx.processMessage(msgData.msg); try { codeGenFunction(ctx, msgData); } catch (IOException e) { e.printStackTrace(); assert false; } } code.write("}\n"); try { codeFile.close(); } catch (IOException e) { e.printStackTrace(); assert false; } progress.worked(1); } for (int i = 0; i < count; i++) namesHeader.format("void Frame%d();\n", i); namesHeader.format("extern void (* Frames[%d])();\n", count); namesSource.format("void (* Frames[%d])() = {\n", count); for (int i = 0; i < count; i++) { namesSource.format(" Frame%d,\n", i); } namesSource.write("};\n"); namesSource.format("const unsigned int FrameCount = %d;\n", count); codeGenCleanup(); progress.worked(1); } void codeGenFrames(final DebugContext dbgCtx, int count, final Shell shell) { this.dbgCtx = dbgCtx; this.count = count; ProgressMonitorDialog dialog = new ProgressMonitorDialog(shell); this.progress = dialog.getProgressMonitor(); try { dialog.run(false, true, this); } catch (InvocationTargetException e) { e.printStackTrace(); assert false; } catch (InterruptedException e) { e.printStackTrace(); } this.dbgCtx = null; this.count = 0; progress = null; } void codeGenFrame(final Frame frame) { Context ctx = frame.startContext.clone(); codeGenSetup(ctx); try { codeFile = new FileWriter("frame0.cpp", false); code = new PrintWriter(codeFile); } catch (IOException e1) { e1.printStackTrace(); assert false; } make.format(" frame0.cpp \\\n"); code.write("#include \"frame_names.h\"\n"); code.format("void Frame0(){\n"); for (int i = 0; i < frame.size(); i++) { final MessageData msgData = frame.get(i); code.format("/* frame function %d: %s %s*/\n", i, msgData.msg.getFunction(), MessageFormatter.format(msgData.msg, false)); ctx.processMessage(msgData.msg); try { codeGenFunction(ctx, msgData); } catch (IOException e) { e.printStackTrace(); assert false; } } code.write("}\n"); namesHeader.write("void Frame0();\n"); namesHeader.write("extern void (* Frames[1])();\n"); namesSource.write("void (* Frames[1])() = {Frame0};\n"); namesSource.write("const unsigned int FrameCount = 1;\n"); codeGenCleanup(); } }