Java tutorial
/* * Copyright (C) 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.ide.eclipse.gltrace; import com.android.ide.eclipse.gltrace.GLProtoBuf.GLMessage; import com.android.ide.eclipse.gltrace.GLProtoBuf.GLMessage.Function; import com.android.ide.eclipse.gltrace.format.GLAPISpec; import com.android.ide.eclipse.gltrace.format.GLMessageFormatter; import com.android.ide.eclipse.gltrace.model.GLCall; import com.android.ide.eclipse.gltrace.model.GLFrame; import com.android.ide.eclipse.gltrace.model.GLTrace; import com.android.ide.eclipse.gltrace.state.transforms.StateTransformFactory; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jface.operation.IRunnableWithProgress; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Set; import java.util.TreeSet; public class TraceFileParserTask implements IRunnableWithProgress { private static final TraceFileReader sReader = new TraceFileReader(); private static final GLMessageFormatter sGLMessageFormatter = new GLMessageFormatter(GLAPISpec.getSpecs()); private String mTraceFilePath; private RandomAccessFile mFile; private List<GLCall> mGLCalls; private Set<Integer> mGLContextIds; private GLTrace mTrace; /** * Construct a GL Trace file parser. * @param path path to trace file */ public TraceFileParserTask(String path) { try { mFile = new RandomAccessFile(path, "r"); //$NON-NLS-1$ } catch (FileNotFoundException e) { throw new IllegalArgumentException(e); } mTraceFilePath = path; mGLCalls = new ArrayList<GLCall>(); mGLContextIds = new TreeSet<Integer>(); } private void addMessage(int index, long traceFileOffset, GLMessage msg, long startTime) { String formattedMsg; try { formattedMsg = sGLMessageFormatter.formatGLMessage(msg); } catch (Exception e) { formattedMsg = String.format("%s()", msg.getFunction().toString()); //$NON-NLS-1$ } GLCall c = new GLCall(index, startTime, traceFileOffset, formattedMsg, msg.getFunction(), msg.hasFb(), msg.getContextId(), msg.getDuration(), msg.getThreadtime()); addProperties(c, msg); try { c.setStateTransformations(StateTransformFactory.getTransformsFor(msg)); } catch (Exception e) { c.setStateTransformationCreationError(e.getMessage()); GlTracePlugin.getDefault().logMessage("Error while creating transformations for " + c.toString() + ":"); GlTracePlugin.getDefault().logMessage(e.getMessage()); } mGLCalls.add(c); mGLContextIds.add(Integer.valueOf(c.getContextId())); } /** Save important values from the {@link GLMessage} in the {@link GLCall} as properties. */ private void addProperties(GLCall c, GLMessage msg) { switch (msg.getFunction()) { case glPushGroupMarkerEXT: // void PushGroupMarkerEXT(sizei length, const char *marker); // save the marker name c.addProperty(GLCall.PROPERTY_MARKERNAME, msg.getArgs(1).getCharValue(0).toStringUtf8()); break; case glVertexAttribPointerData: // void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, // GLboolean normalized, GLsizei stride, const GLvoid* ptr, // int minIndex, int maxIndex) c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_SIZE, Integer.valueOf(msg.getArgs(1).getIntValue(0))); c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_TYPE, GLEnum.valueOf(msg.getArgs(2).getIntValue(0))); c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_DATA, msg.getArgs(5).getRawBytes(0).toByteArray()); break; default: break; } } /** * Parse the entire file and create a {@link GLTrace} object that can be retrieved * using {@link #getTrace()}. */ @Override public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { long fileLength; try { fileLength = mFile.length(); } catch (IOException e1) { fileLength = 0; } monitor.beginTask("Parsing OpenGL Trace File", fileLength > 0 ? 100 : IProgressMonitor.UNKNOWN); List<GLFrame> glFrames = null; try { GLMessage msg = null; int msgCount = 0; long filePointer = mFile.getFilePointer(); int percentParsed = 0; // counters that maintain some statistics about the trace messages long minTraceStartTime = Long.MAX_VALUE; while ((msg = sReader.getMessageAtOffset(mFile, -1)) != null) { if (minTraceStartTime > msg.getStartTime()) { minTraceStartTime = msg.getStartTime(); } addMessage(msgCount, filePointer, msg, msg.getStartTime() - minTraceStartTime); filePointer = mFile.getFilePointer(); msgCount++; if (monitor.isCanceled()) { throw new InterruptedException(); } if (fileLength > 0) { int percentParsedNow = (int) ((filePointer * 100) / fileLength); monitor.worked(percentParsedNow - percentParsed); percentParsed = percentParsedNow; } } if (mGLContextIds.size() > 1) { // if there are multiple contexts, then the calls may arrive at the // host out of order. So we perform a sort based on the invocation time. Collections.sort(mGLCalls, new Comparator<GLCall>() { @Override public int compare(GLCall c1, GLCall c2) { long diff = (c1.getStartTime() - c2.getStartTime()); // We could return diff casted to an int. But in Java, casting // from a long to an int truncates the bits and will not preserve // the sign. So we resort to comparing the diff to 0 and returning // the sign. if (diff == 0) { return 0; } else if (diff > 0) { return 1; } else { return -1; } } }); // reassign indices after sorting for (int i = 0; i < mGLCalls.size(); i++) { mGLCalls.get(i).setIndex(i); } } glFrames = createFrames(mGLCalls); } catch (Exception e) { throw new InvocationTargetException(e); } finally { try { mFile.close(); } catch (IOException e) { // ignore exception while closing file } monitor.done(); } File f = new File(mTraceFilePath); TraceFileInfo fileInfo = new TraceFileInfo(mTraceFilePath, f.length(), f.lastModified()); mTrace = new GLTrace(fileInfo, glFrames, mGLCalls, new ArrayList<Integer>(mGLContextIds)); } /** Assign GL calls to GL Frames. */ private List<GLFrame> createFrames(List<GLCall> calls) { List<GLFrame> glFrames = new ArrayList<GLFrame>(); int startCallIndex = 0; int frameIndex = 0; for (int i = 0; i < calls.size(); i++) { GLCall c = calls.get(i); if (c.getFunction() == Function.eglSwapBuffers) { glFrames.add(new GLFrame(frameIndex, startCallIndex, i + 1)); startCallIndex = i + 1; frameIndex++; } } // assign left over calls at the end to the last frame if (startCallIndex != mGLCalls.size()) { glFrames.add(new GLFrame(frameIndex, startCallIndex, mGLCalls.size())); } return glFrames; } /** * Retrieve the trace object constructed from messages in the trace file. */ public GLTrace getTrace() { return mTrace; } }