e.printStackTrace();
}
screenshotTimer = new Timer();
- screenshotTimer.scheduleAtFixedRate(new ScreenshotTimerTask(),
- 1000, period);
+ screenshotTimer.scheduleAtFixedRate(new ScreenshotTimerTask(), 1000, period);
}
-
- screenshotTimer = new Timer();
- screenshotTimer.scheduleAtFixedRate(new ScreenshotTimerTask(), 1000, period);
}
}
--- /dev/null
- import org.tizen.dynamicanalyzer.util.DALogger;
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * 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.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.opengl;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLAPINameDefine;
- DALogger.getInstance().error("undefine uniform api : " + apiName);
++import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
+
+public class GLExtractUniformDataMaker {
+
+ static final int PRINT_UNIFORM_VALUE_LENGTH = 10;
+
+ boolean isUniformAPI(String apiName) {
+ if (apiName.contains(GLAPINameDefine.API_UNIFORM)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ String getUniformData(String apiName, String parameter) {
+ if (apiName.contains(GLAPINameDefine.API_UNIFORM_MATRIX)) {
+ return getUniformDataFromPointer(apiName, parameter);
+ } else if (apiName.contains(GLAPINameDefine.API_UNIFORM_1I)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_2I)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_3I)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_4I)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_1F)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_2F)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_3F)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_4F)) {
+ return getUniformParameterValue(parameter);
+ } else if (apiName.contains(GLAPINameDefine.API_UNIFORM_1IV)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_2IV)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_3IV)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_4IV)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_1FV)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_2FV)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_3FV)
+ || apiName.contains(GLAPINameDefine.API_UNIFORM_4FV)) {
+ return getUniformDataFromPointer(apiName, parameter);
+ } else {
- DALogger.getInstance().error(
++ Logger.error("undefine uniform api : " + apiName);
+ }
+ return null;
+ }
+
+ private String getUniformParameterValue(String parameter) {
+ String[] parameterArray = getParameterArray(parameter);
+ StringBuffer returnUniform = new StringBuffer();
+ if(null == parameterArray){
+ return parameter;
+ }
+ for (int i = 1; i < parameterArray.length; i++) {
+ returnUniform.append(parameterArray[i]);
+ if (i != parameterArray.length - 1) {
+ returnUniform.append(CommonConstants.COMMA).append(CommonConstants.SPACE);
+ }
+ }
+ return returnUniform.toString();
+ }
+
+ private String getUniformDataFromPointer(String apiName, String parameter) {
+ String[] uniformArray = getParameterArray(getUniformParameter(parameter));
+ if (null == uniformArray) {
- DALogger.getInstance().error("undefine uniform api : " + apiName);
++ Logger.error(
+ "parameter size is wrong : " + apiName + " parameter : " + parameter);
+ return parameter;
+ }
+ return getAlignmentTableFormat(apiName, uniformArray);
+ }
+
+
+ private String getAlignmentTableFormat(String apiName, String[] uniformArray) {
+ int uniformColumnSize = getUnifomColumnSize(apiName);
+ StringBuffer returnUniformValue = new StringBuffer(CommonConstants.TAB);
+ //cipher correction to look better in the table view.
+ for (int i = 0, columnIndex = 1; i < uniformArray.length; i++, columnIndex++) {
+ if (AnalyzerUtil.isInteger(uniformArray[i])) {
+ returnUniformValue.append(String.format("%010d", uniformArray[i]));//$NON-NLS-1$
+ } else {
+ returnUniformValue.append(getFloatValueToDefineLength(uniformArray[i]));
+ }
+ if (i == uniformArray.length - 1) {
+ continue;
+ }
+ returnUniformValue.append(CommonConstants.COMMA).append(CommonConstants.SPACE);
+ if (columnIndex % uniformColumnSize == 0) {
+ returnUniformValue.append(CommonConstants.NEW_LINE).append(CommonConstants.TAB);
+ }
+ }
+ return returnUniformValue.toString();
+ }
+
+ private String getFloatValueToDefineLength(String value) {
+ if (!value.contains(CommonConstants.DOT)) {
+ return value;
+ }
+ String floatValue = String.format("%.7f", Double.parseDouble(value));//$NON-NLS-1$
+ String[] floatValueSplit = floatValue.split("\\.");//$NON-NLS-1$
+ String aboveValue = floatValueSplit[0];
+ StringBuffer returnValue = new StringBuffer();
+ if (!aboveValue.contains("-")) {//$NON-NLS-1$
+ returnValue.append(CommonConstants.SPACE);
+ }
+ returnValue.append(aboveValue).append(CommonConstants.DOT);
+ returnValue.append(floatValueSplit[1]);
+ if (returnValue.toString().length() > PRINT_UNIFORM_VALUE_LENGTH) {
+ returnValue.replace(10, returnValue.toString().length(), CommonConstants.EMPTY);
+ }
+ return returnValue.toString();
+ }
+
+ private String[] getParameterArray(String uniformValue) {
+ if (!uniformValue.contains(CommonConstants.COMMA)) {
+ return null;
+ }
+ return uniformValue.split(CommonConstants.COMMA);
+ }
+
+ private String getUniformParameter(String parameter) {
+ if (!parameter.contains(CommonConstants.OPEN_SQUARE_BRACKET)) {
+ return parameter;
+ }
+ String[] parameterSplit = parameter.split("\\[");//$NON-NLS-1$
+ String returnUniformValue = parameterSplit[parameterSplit.length - 1];
+ return returnUniformValue.replace(CommonConstants.CLOSE_SQUARE_BRACKET,
+ CommonConstants.EMPTY);
+ }
+
+ private int getUnifomColumnSize(String apiName) {
+ if (apiName.contains("1")) {//$NON-NLS-1$
+ return 1;
+ } else if (apiName.contains("2")) {//$NON-NLS-1$
+ return 2;
+ } else if (apiName.contains("3")) {//$NON-NLS-1$
+ return 3;
+ } else if (apiName.contains("4")) {//$NON-NLS-1$
+ return 4;
+ } else {
++ Logger.error("undefine uniform api : " + apiName);
+ return 1;
+ }
+ }
+}
import org.tizen.dynamicanalyzer.database.DBTable;
import org.tizen.dynamicanalyzer.database.SqlConnectionManager;
import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLContextNameEnum;
- import org.tizen.dynamicanalyzer.util.DALogger;
+ import org.tizen.dynamicanalyzer.util.Logger;
-public class GLStateDBTableManager extends DBTable {
+public class GLCommonStateDBTableManager extends DBTable {
private static final String TABLENAME = "GL_CONTEXT";//$NON-NLS-1$
private String[] columnName = null;
private int rid = 0;
if (isIntegerType(i)) {
types[i] = DBConstants.INTEGER;
+ } else if (isLongType(i)) {
+ types[i] = DBConstants.LONG;
} else if (isBooleans(i)) {
types[i] = DBConstants.BOOLEAN;
- } else if (i == GLContextNameEnum.VIEWPORT.ordinal()
- || i == GLContextNameEnum.BLEND_COLOR.ordinal()
- || i == GLContextNameEnum.SCISSOR.ordinal()) {
- types[i] = "VARCHAR(24)";
+ } else if (isStringType(i)) {
+ types[i] = "VARCHAR(24)";//$NON-NLS-1$
} else if (i == GLContextNameEnum.GVA_ENABLED.ordinal()) {
- types[i] = "VARCHAR(144)";
- } else if (i == GLContextNameEnum.GVA_SIZE.ordinal()
- || i == GLContextNameEnum.GVA_NORMAL.ordinal()
- || i == GLContextNameEnum.GVA_STRIDE.ordinal()) {
- types[i] = "VARCHAR(64)";
- } else if (i == GLContextNameEnum.GVA_TYPE.ordinal()) {
- types[i] = "VARCHAR(192)";
- } else if (i == GLContextNameEnum.GVA_POINTER.ordinal()) {
- types[i] = "VARCHAR(176)";
- } else if (i == GLContextNameEnum.GVA_V0.ordinal()
- || i == GLContextNameEnum.GVA_V1.ordinal()
- || i == GLContextNameEnum.GVA_V2.ordinal()
- || i == GLContextNameEnum.GVA_V3.ordinal()) {
- types[i] = "VARCHAR(248)";
- } else if (i == GLContextNameEnum.VBO_BINDING.ordinal()) {
- types[i] = "VARCHAR(192)";
- } else if (i == GLContextNameEnum.VBO_SIZE.ordinal()
- || i == GLContextNameEnum.VBO_Data.ordinal()
- || i == GLContextNameEnum.VBO_ID.ordinal()
- || i == GLContextNameEnum.VBO_USAGE.ordinal()) {
- types[i] = "VARCHAR(64)";
- } else if (i == GLContextNameEnum.FRAME_BUFFER_BINDING.ordinal()) {
- types[i] = "VARCHAR(32)";
+ types[i] = DBConstants.BOOLEAN_ARRAY;
+ } else if (isIntegerArray(i)) {
+ types[i] = DBConstants.INTEGER_ARRAY;
+ } else if (isLongArray(i)) {
+ types[i] = DBConstants.BIGINT_ARRAY;
} else {
- DALogger.getInstance().error("undefine column : " + i);
+ Logger.error("undefine column : " + i);
}
}
for (int i = 0; i < length; i++) {
if (columnsize != rowData.size()) {
isPrepared = false;
} else {
- for (int i = 0; i < columnsize; i++) {
-
+ for (int index = 0; index < columnsize; index++) {
try {
- if (isIntegerType(i)) {
- prep.setInt(i + 1, (Integer) (rowData.get(i)));
- } else if (isBooleans(i)) {
- boolean booleanResutl = (Boolean) (rowData.get(i));
- if (booleanResutl) {
- prep.setBoolean(i + 1, true);
- } else {
- prep.setBoolean(i + 1, false);
- }
-
+ if (isBooleanArray(index)) {
+ SqlConnectionManager.setArrayToPreparedStatement(index,
+ DBConstants.BOOLEAN, prep, rowData);
+ } else if (isIntegerArray(index)) {
+ SqlConnectionManager.setArrayToPreparedStatement(index,
+ DBConstants.INTEGER, prep, rowData);
+ } else if (isLongArray(index)) {
+ SqlConnectionManager.setArrayToPreparedStatement(index, DBConstants.LONG,
+ prep, rowData);
+ } else if (isIntegerType(index)) {
+ prep.setInt(index + 1, (Integer) (rowData.get(index)));
+ } else if (isLongType(index)) {
+ prep.setLong(index + 1, (Long) (rowData.get(index)));
+ } else if (isBooleans(index)) {
+ prep.setBoolean(index + 1, (Boolean) (rowData.get(index)));
+ } else if (isStringType(index)) {
+ prep.setString(index + 1, (String) (rowData.get(index)));
} else {
- DALogger.getInstance().error("undefine column : " + index);
- prep.setString(i + 1, (String) (rowData.get(i)));
++ Logger.error("undefine column : " + index);
}
} catch (SQLException e) {
e.printStackTrace();
--- /dev/null
- import org.tizen.dynamicanalyzer.util.DALogger;
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * 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.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.opengl.data;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.swap.model.data.GLES20LogData;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLAPINameDefine;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLConstantDefine;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLContextNameEnum;
- private static final DALogger DA_LOG = DALogger.getInstance();
++import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
+
+public class GLCommonStateDataMaker {
- DA_LOG.error("GL context init API - size of the parameter of the context log column is not 2");
+ private GLStateDataManager glStateDataManager = null;
+
+ public GLCommonStateDataMaker(GLStateDataManager glStateDataManager) {
+ this.glStateDataManager = glStateDataManager;
+ }
+
+ private GLStateDataManager getStateDataManager() {
+ return this.glStateDataManager;
+ }
+
+ public void extractGLCommonAPIParameter(GLES20LogData logData) {
+ int apiType = logData.getApiType();
+ String apiName = logData.getApiName();
+ if (apiType == GLStateDataManager.API_TYPE_INIT) {
+ initContextValue(logData);
+ } else if (glStateDataManager.isNormalAPIStatusForExtractParameter(logData)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.CONTEXT_ID.ordinal(), logData.getCurrentContextID());
+ if (apiName.equals(GLAPINameDefine.API_GL_BLEND_COLOR)
+ || apiName.equals(GLAPINameDefine.API_GL_BLEND_EQ)
+ || apiName.equals(GLAPINameDefine.API_GL_BLEND_EQ_SEP)
+ || apiName.equals(GLAPINameDefine.API_GL_BLEND_FUNC)
+ || apiName.equals(GLAPINameDefine.API_GL_BLEND_FUNC_SEP)) {
+ extractBlendGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_BUFFER_GEN)
+ || apiName.equals(GLAPINameDefine.API_GL_BUFFER_DEL)
+ || apiName.equals(GLAPINameDefine.API_GL_BUFFER_BIND)
+ || apiName.equals(GLAPINameDefine.API_GL_BUFFER_DATA)) {
+ extractVBOGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_CULLFACE)
+ || apiName.equals(GLAPINameDefine.API_GL_FRONTFACE)) {
+ extractCullingGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_DEPTH_FUNC)
+ || apiName.equals(GLAPINameDefine.API_GL_DEPTH_RANGEF)) {
+ extractDepthGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_ENABLE)) {
+ extractEnableGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_DISABLE_VAA)
+ || apiName.equals(GLAPINameDefine.API_GL_ENABLE_VAA)) {
+ extractGVAGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_LINEWIDTH)) {
+ extractLineGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_PIXEL_STOREI)) {
+ extractPackAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_POLY_OFFSET)) {
+ extractPolyGLAPIPrameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_SCISSOR)) {
+ extractSissorGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_STENCIL_FUNC)
+ || apiName.equals(GLAPINameDefine.API_GL_STENCIL_FUNC_SEP)
+ || apiName.equals(GLAPINameDefine.API_GL_STENCIL_OP)
+ || apiName.equals(GLAPINameDefine.API_GL_STENCIL_OP_SEP)) {
+ extractStencilGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB1F)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB2F)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB3F)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB4F)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB1FV)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB2FV)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB3FV)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB4FV)
+ || apiName.equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB_POINTER)) {
+ extractVertexGLAPIParameter(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_GL_VIEWPORT)) {
+ extractViewPortGLAPIParameter(logData);
+ }
+ }
+ }
+
+ private void initContextValue(GLES20LogData logData) {
+ String contextValue = logData.getContextValue().trim();
+ GLContextDataManager currentContextValue = getStateDataManager().getGLContextDataManager(
+ logData.getCurrentContextID());
+ if (logData.getApiType() != GLStateDataManager.API_TYPE_INIT) {
+ return;
+ }
+ if (!contextValue.contains(CommonConstants.COMMA)) {
+ return;
+ }
+ String contextValues[] = contextValue.split(CommonConstants.COMMA);
+ if (contextValues.length != 2) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_LINEWIDTH);
++ Logger.error("GL context init API - size of the parameter of the context log column is not 2");
+ return;
+ }
+ currentContextValue.setTextureUnits(Integer.parseInt(contextValues[0].trim()));
+ currentContextValue.setVertexAttribs(Integer.parseInt(contextValues[1].trim()));
+ }
+
+ private void extractLineGLAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (!logData.getApiName().equals(GLAPINameDefine.API_GL_LINEWIDTH)) {
+ return;
+ }
+ if (parameters.length != 1) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_PIXEL_STOREI);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_LINEWIDTH);
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.LINE_WIDTH.ordinal(),
+ Integer.parseInt(parameters[0]));
+ }
+
+ private void extractPackAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (!logData.getApiName().equals(GLAPINameDefine.API_GL_PIXEL_STOREI)) {
+ return;
+ }
+
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter undefine : " + logData.getApiName());
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_PIXEL_STOREI);
+ return;
+ }
+
+ if (parameters[0].equals(Long.toString(AnalyzerUtil
+ .addrToLong(GLAPINameDefine.GL_PACK_ALIGNMENT)))) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.PACK_ALIGN.ordinal(), Integer.parseInt(parameters[1]));
+ } else if (parameters[0].equals(Long.toString(AnalyzerUtil
+ .addrToLong(GLAPINameDefine.GL_UNPACK_ALIGNMENT)))) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.UNPACK_ALIGN.ordinal(), Integer.parseInt(parameters[1]));
+ } else {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_SCISSOR);
++ Logger.error("GL extract API parameter undefine : " + logData.getApiName());
+ }
+ }
+
+ private void extractGVAGLAPIParameter(GLES20LogData logData) {
+ GLContextDataManager currentContextValue = getStateDataManager().getGLContextDataManager(
+ logData.getCurrentContextID());
+ if (logData.getApiName().equals(GLAPINameDefine.API_GL_DISABLE_VAA)) {
+ currentContextValue.gvaEnabledValueList.set(Integer.parseInt(logData.getArgs()), false);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.GVA_ENABLED.ordinal(),
+ currentContextValue.gvaEnabledValueList);
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_ENABLE_VAA)) {
+ currentContextValue.gvaEnabledValueList.set(Integer.parseInt(logData.getArgs()), true);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.GVA_ENABLED.ordinal(),
+ currentContextValue.gvaEnabledValueList);
+ }
+ }
+
+ private void extractEnableGLAPIParameter(GLES20LogData logData) {
+ String parameter = logData.getArgs().trim();
+ if (!logData.getApiName().equals(GLAPINameDefine.API_GL_ENABLE)) {
+ return;
+ }
+ if (parameter.equals(GLAPINameDefine.GL_BLEND)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_ENABLED.ordinal(), true);
+ } else if (parameter.equals(GLAPINameDefine.GL_CULL_FACE)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.CULLING_ENABLED.ordinal(), true);
+ } else if (parameter.equals(GLAPINameDefine.GL_DEPTH_TEST)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.DEPTH_ENABLED.ordinal(), true);
+ } else if (parameter.equals(GLAPINameDefine.GL_DITHER)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.DITHER_ENABLED.ordinal(), true);
+ } else if (parameter.equals(GLAPINameDefine.GL_POLYGON_OFFSET_FILL)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.POLY_ENABLED.ordinal(), true);
+ } else if (parameter.equals(GLAPINameDefine.GL_SCISSOR_TEST)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.SCISSOR_ENABLED.ordinal(), true);
+ } else if (parameter.equals(GLAPINameDefine.GL_STENCIL_TEST)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_ENABLED.ordinal(), true);
+ }
+ }
+
+ private void extractPolyGLAPIPrameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (!logData.getApiName().equals(GLAPINameDefine.API_GL_POLY_OFFSET)) {
+
+ }
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.POLY_FACTOR.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.POLY_UNITS.ordinal(),
+ Integer.parseInt(parameters[1]));
+ }
+
+ private void extractSissorGLAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (!logData.getApiName().equals(GLAPINameDefine.API_GL_SCISSOR)) {
+ return;
+ }
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_VIEWPORT);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_SCISSOR);
+ return;
+ }
+
+ StringBuffer scissor = new StringBuffer();
+ scissor.append(parameters[0]).append(CommonConstants.COMMA).append(parameters[1])
+ .append(CommonConstants.COMMA).append(parameters[2]).append(CommonConstants.COMMA)
+ .append(parameters[3]);
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.SCISSOR.ordinal(),
+ scissor.toString());
+ }
+
+ private void extractViewPortGLAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (!logData.getApiName().equals(GLAPINameDefine.API_GL_VIEWPORT)) {
+ return;
+ }
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + logData.getApiName());
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_VIEWPORT);
+ return;
+ }
+
+ StringBuffer viewPort = new StringBuffer();
+ viewPort.append(parameters[0].trim()).append(CommonConstants.COMMA)
+ .append(parameters[1].trim()).append(CommonConstants.COMMA)
+ .append(parameters[2].trim()).append(CommonConstants.COMMA)
+ .append(parameters[3].trim());
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.VIEWPORT.ordinal(),
+ viewPort.toString());
+ }
+
+ private void extractDepthGLAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (logData.getApiName().equals(GLAPINameDefine.API_GL_DEPTH_FUNC)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + logData.getApiName());
++ Logger.error("GL extract API parameter : " + logData.getApiName());
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.DEPTH_FUNC.ordinal(), Integer.parseInt(parameters[0]));
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_DEPTH_RANGEF)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_CULLFACE);
++ Logger.error("GL extract API parameter : " + logData.getApiName());
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.DEPTH_RANGE_N.ordinal(), Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.DEPTH_RANGE_F.ordinal(), Integer.parseInt(parameters[1]));
+ }
+ }
+
+ private void extractCullingGLAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (logData.getApiName().equals(GLAPINameDefine.API_GL_CULLFACE)) {
+ if (parameters.length != 1) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_FRONTFACE);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_CULLFACE);
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.CULLING_MODE.ordinal(), Integer.parseInt(parameters[0]));
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_FRONTFACE)) {
+ if (parameters.length != 1) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BUFFER_BIND);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_FRONTFACE);
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.CULLING_ORIENTATION.ordinal(),
+ Integer.parseInt(parameters[0]));
+ }
+
+ }
+
+ private void extractVBOGLAPIParameter(GLES20LogData logData) {
+ long contextId = logData.getCurrentContextID();
+ GLContextDataManager currentContextValue = getStateDataManager().getGLContextDataManager(
+ contextId);
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (logData.getApiName().equals(GLAPINameDefine.API_GL_BUFFER_DEL)) {
+ if (Integer.parseInt(parameters[0]) == currentContextValue.vboArrayBinding) {
+ currentContextValue.vboArrayBinding = 0;
+ currentContextValue.vboArrayID = 0;
+ currentContextValue.vboArraySize = 0;
+ currentContextValue.vboArrayData = 0;
+ currentContextValue.vboArrayUsage = 0;
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_BINDING.ordinal(),
+ currentContextValue.vboArrayBinding);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_ID.ordinal(), currentContextValue.vboArrayID);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_SIZE.ordinal(),
+ currentContextValue.vboArraySize);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_DATA.ordinal(),
+ currentContextValue.vboArrayData);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_USAGE.ordinal(),
+ currentContextValue.vboArrayUsage);
+ } else {
+ currentContextValue.vboElementBinding = 0;
+ currentContextValue.vboElementID = 0;
+ currentContextValue.vboElementSize = 0;
+ currentContextValue.vboElementData = 0;
+ currentContextValue.vboElementUsage = 0;
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_BINDING.ordinal(),
+ currentContextValue.vboElementBinding);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_ID.ordinal(),
+ currentContextValue.vboElementID);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_SIZE.ordinal(),
+ currentContextValue.vboElementSize);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_DATA.ordinal(),
+ currentContextValue.vboElementData);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_USAGE.ordinal(),
+ currentContextValue.vboElementUsage);
+ }
+
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_BUFFER_BIND)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BUFFER_DATA);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BUFFER_BIND);
+ return;
+ }
+ if (Integer.parseInt(parameters[1]) == 0) {
+ return;
+ }
+
+ if (GLConstantDefine.getConstantString(Integer.parseInt(parameters[0])).equals(
+ "GL_ARRAY_BUFFER")) {
+ currentContextValue.vboArrayBinding = Integer.parseInt(parameters[1]);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_BINDING.ordinal(),
+ currentContextValue.vboArrayBinding);
+ } else {
+ currentContextValue.vboElementBinding = Integer.parseInt(parameters[1]);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_BINDING.ordinal(),
+ currentContextValue.vboElementBinding);
+ }
+
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_BUFFER_DATA)) {
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_COLOR);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BUFFER_DATA);
+ return;
+ }
+ if (GLConstantDefine.getConstantString(Integer.parseInt(parameters[0])).equals(
+ "GL_ARRAY_BUFFER")) {
+ currentContextValue.vboArraySize = Integer.parseInt(parameters[1]);
+ currentContextValue.vboArrayData = AnalyzerUtil.addrToLong(parameters[2]);
+ currentContextValue.vboArrayUsage = Integer.parseInt(parameters[3]);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_SIZE.ordinal(),
+ currentContextValue.vboArraySize);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_DATA.ordinal(),
+ currentContextValue.vboArrayData);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ARRAY_USAGE.ordinal(),
+ currentContextValue.vboArrayUsage);
+ } else {
+ currentContextValue.vboElementSize = Integer.parseInt(parameters[1]);
+ currentContextValue.vboElementData = AnalyzerUtil.addrToLong(parameters[2]);
+ currentContextValue.vboElementUsage = Integer.parseInt(parameters[3]);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_SIZE.ordinal(),
+ currentContextValue.vboElementSize);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_DATA.ordinal(),
+ currentContextValue.vboElementData);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.VBO_ELEMENT_USAGE.ordinal(),
+ currentContextValue.vboElementUsage);
+ }
+ }
+ }
+
+ private void extractBlendGLAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (logData.getApiName().equals(GLAPINameDefine.API_GL_BLEND_COLOR)) {
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_EQ);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_COLOR);
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_COLOR.ordinal(),
+ parameters[0] + CommonConstants.COMMA + parameters[1] + CommonConstants.COMMA
+ + parameters[2] + CommonConstants.COMMA + parameters[3]);
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_BLEND_EQ)) {
+ if (parameters.length != 1) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_EQ_SEP);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_EQ);
+ return;
+ }
+ getStateDataManager()
+ .updateStateAtCurrentContext(GLContextNameEnum.BLEND_EQUATION_RGB.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_EQUATION_ALPHA.ordinal(),
+ Integer.parseInt(parameters[0]));
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_BLEND_EQ_SEP)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_FUNC);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_EQ_SEP);
+ return;
+ }
+ getStateDataManager()
+ .updateStateAtCurrentContext(GLContextNameEnum.BLEND_EQUATION_RGB.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_EQUATION_ALPHA.ordinal(),
+ Integer.parseInt(parameters[1]));
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_BLEND_FUNC)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_FUNC_SEP);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_FUNC);
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_SRC_RGB.ordinal(), Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_SRC_ALPHA.ordinal(), Integer.parseInt(parameters[1]));
+
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_DEST_RGB.ordinal(), Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_DEST_ALPHA.ordinal(), Integer.parseInt(parameters[1]));
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_BLEND_FUNC_SEP)) {
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_STENCIL_FUNC);
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_BLEND_FUNC_SEP);
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_SRC_RGB.ordinal(), Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_DEST_RGB.ordinal(), Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_SRC_ALPHA.ordinal(), Integer.parseInt(parameters[2]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.BLEND_DEST_ALPHA.ordinal(), Integer.parseInt(parameters[3]));
+ }
+
+ }
+
+ private void extractStencilGLAPIParameter(GLES20LogData logData) {
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ if (logData.getApiName().equals(GLAPINameDefine.API_GL_STENCIL_FUNC)) {
+ if (parameters.length != 3) {
- DA_LOG.error("GL extract API parameter : "
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_STENCIL_FUNC);
+ return;
+ }
+ getStateDataManager()
+ .updateStateAtCurrentContext(GLContextNameEnum.STENCIL_FRONT_FUNC.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_REF.ordinal(), Integer.parseInt(parameters[1]));
+ getStateDataManager()
+ .updateStateAtCurrentContext(GLContextNameEnum.STENCIL_FRONT_MASK.ordinal(),
+ Integer.parseInt(parameters[2]));
+
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_FUNC.ordinal(), Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_REF.ordinal(), Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_MASK.ordinal(), Integer.parseInt(parameters[2]));
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_STENCIL_FUNC_SEP)) {
+ if (parameters.length != 3) {
- DA_LOG.error("GL extract API parameter : " + GLAPINameDefine.API_GL_STENCIL_OP);
++ Logger.error("GL extract API parameter : "
+ + GLAPINameDefine.API_GL_STENCIL_FUNC_SEP);
+ return;
+ }
+ if (parameters[0].equals(GLAPINameDefine.GL_FRONT)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_FUNC.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_REF.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_MASK.ordinal(),
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[0].equals(GLAPINameDefine.GL_BACK)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_FUNC.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_REF.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_MASK.ordinal(),
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[0].equals(GLAPINameDefine.GL_FRONT_AND_BACK)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_FUNC.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_REF.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_MASK.ordinal(),
+ Integer.parseInt(parameters[2]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_FUNC.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_REF.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_MASK.ordinal(),
+ Integer.parseInt(parameters[2]));
+ }
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_STENCIL_OP)) {
+ if (parameters.length != 3) {
- DA_LOG.error("GL extract API parameter : " + logData.getApiName());
++ Logger.error("GL extract API parameter : " + GLAPINameDefine.API_GL_STENCIL_OP);
+ return;
+ }
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_S_FAIL.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_D_FAIL.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_D_PASS.ordinal(),
+ Integer.parseInt(parameters[2]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_S_FAIL.ordinal(),
+ Integer.parseInt(parameters[0]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_D_FAIL.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_D_PASS.ordinal(),
+ Integer.parseInt(parameters[2]));
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_STENCIL_OP_SEP)) {
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + logData.getApiName());
++ Logger.error("GL extract API parameter : " + logData.getApiName());
+ return;
+ }
+ if (parameters[0].equals(GLAPINameDefine.GL_FRONT)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_S_FAIL.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_D_FAIL.ordinal(),
+ Integer.parseInt(parameters[2]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_D_PASS.ordinal(),
+ Integer.parseInt(parameters[3]));
+ } else if (parameters[0].equals(GLAPINameDefine.GL_BACK)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_S_FAIL.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_D_FAIL.ordinal(),
+ Integer.parseInt(parameters[2]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_D_PASS.ordinal(),
+ Integer.parseInt(parameters[3]));
+ } else if (parameters[0].equals(GLAPINameDefine.GL_FRONT_AND_BACK)) {
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_S_FAIL.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_D_FAIL.ordinal(),
+ Integer.parseInt(parameters[2]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_FRONT_D_PASS.ordinal(),
+ Integer.parseInt(parameters[3]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_S_FAIL.ordinal(),
+ Integer.parseInt(parameters[1]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_D_FAIL.ordinal(),
+ Integer.parseInt(parameters[2]));
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.STENCIL_BACK_D_PASS.ordinal(),
+ Integer.parseInt(parameters[3]));
+ }
+ }
+ }
+
+ private void extractVertexGLAPIParameter(GLES20LogData logData) {
+ GLContextDataManager currentContextValue = getStateDataManager().getGLContextDataManager(
+ logData.getCurrentContextID());
+ String parameters[] = logData.getArgs()
+ .split(CommonConstants.COMMA + CommonConstants.SPACE);
+ String contextValues[] = logData.getContextValue().trim().split(CommonConstants.COMMA);
+
+ if (logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB1F)
+ || logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB2F)
+ || logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB3F)
+ || logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB4F)
+ || logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB1FV)
+ || logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB2FV)
+ || logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB3FV)
+ || logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB4FV)) {
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + logData.getApiName());
++ Logger.error("GL extract API parameter : " + logData.getApiName());
+ return;
+ }
+ int gvaIndex = Integer.parseInt(parameters[0]);
+ currentContextValue.gvaV0ValueList.set(gvaIndex, Integer.parseInt(contextValues[0]));
+ currentContextValue.gvaV1ValueList.set(gvaIndex, Integer.parseInt(contextValues[1]));
+ currentContextValue.gvaV2ValueList.set(gvaIndex, Integer.parseInt(contextValues[2]));
+ currentContextValue.gvaV3ValueList.set(gvaIndex, Integer.parseInt(contextValues[3]));
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.GVA_V0.ordinal(),
+ currentContextValue.gvaV0ValueList);
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.GVA_V1.ordinal(),
+ currentContextValue.gvaV1ValueList);
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.GVA_V2.ordinal(),
+ currentContextValue.gvaV2ValueList);
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.GVA_V3.ordinal(),
+ currentContextValue.gvaV3ValueList);
+ } else if (logData.getApiName().equals(GLAPINameDefine.API_GL_VERTEX_ATTRIB_POINTER)) {
+ if (parameters.length != 6) {
++ Logger.error("GL extract API parameter : " + logData.getApiName());
+ return;
+ }
+ int gvaIndex = Integer.parseInt(parameters[0]);
+ currentContextValue.gvaSizeValueList.set(gvaIndex, Integer.parseInt(parameters[1]));
+ currentContextValue.gvaTypeValueList.set(gvaIndex, Integer.parseInt(parameters[2]));
+ currentContextValue.gvaNormalValueList.set(gvaIndex, Integer.parseInt(parameters[3]));
+ currentContextValue.gvaStrideValueList.set(gvaIndex, Integer.parseInt(parameters[4]));
+ currentContextValue.gvaPointerValueList.set(gvaIndex,
+ AnalyzerUtil.addrToLong(parameters[5]));
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.GVA_SIZE.ordinal(),
+ currentContextValue.gvaSizeValueList);
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.GVA_TYPE.ordinal(),
+ currentContextValue.gvaTypeValueList);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.GVA_NORMAL.ordinal(), currentContextValue.gvaNormalValueList);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.GVA_STRIDE.ordinal(), currentContextValue.gvaStrideValueList);
+ getStateDataManager().updateStateAtCurrentContext(
+ GLContextNameEnum.GVA_POINTER.ordinal(),
+ currentContextValue.gvaPointerValueList);
+ }
+ }
+
+}
--- /dev/null
- import org.tizen.dynamicanalyzer.util.DALogger;
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * 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.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.opengl.data;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.swap.model.data.GLES20LogData;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLAPINameDefine;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLContextNameEnum;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLSharingContextType;
- private static final DALogger DA_LOG = DALogger.getInstance();
++import org.tizen.dynamicanalyzer.util.Logger;
+import org.tizen.dynamicanalyzer.utils.AnalyzerUtil;
+
+public class GLContextSharingDataMaker {
- DA_LOG.error("GL extract sharing context API parameter : " + apiName);
+ private GLStateDataManager glStateDataManager = null;
+
+ public GLContextSharingDataMaker(GLStateDataManager glStateDataManager) {
+ this.glStateDataManager = glStateDataManager;
+ }
+
+ private GLStateDataManager getStateDataManager() {
+ return this.glStateDataManager;
+ }
+
+ public void extractSharingContextAPIParameter(GLES20LogData logData) {
+ String apiName = logData.getApiName();
+ if (!apiName.equals(GLAPINameDefine.API_EGL_CREATE_CONTEXT)
+ && !apiName.equals(GLAPINameDefine.API_EVAS_GL_CREATE_CONTEXT)) {
+ return;
+ }
+ if (glStateDataManager.isNormalAPIStatusForExtractParameter(logData)) {
+ eglAPILogManager(logData);
+ }
+ }
+
+ private void eglAPILogManager(GLES20LogData logData) {
+ String apiName = logData.getApiName();
+ if (apiName.equals(GLAPINameDefine.API_EGL_CREATE_CONTEXT)) {
+ insertContextOfEGL(logData);
+ } else if (apiName.equals(GLAPINameDefine.API_EVAS_GL_CREATE_CONTEXT)) {
+ insertContextOfEvasGL(logData);
+ } else {
- DA_LOG.error("GL extract API parameter : " + apiName);
++ Logger.error("GL extract sharing context API parameter : " + apiName);
+ }
+ }
+
+ private void insertContextOfEGL(GLES20LogData logData) {
+ String apiName = logData.getApiName();
+ String parameter = logData.getArgs();
+ String parameters[] = parameter.split(CommonConstants.COMMA + CommonConstants.SPACE);
+ String returnValue = logData.getReturn();
+ if (parameters.length != 4) {
- DA_LOG.error("GL extract API parameter : " + apiName);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ long currentContextId = AnalyzerUtil.addrToLong(parameters[2]);
+ long sharingContextId = AnalyzerUtil.addrToLong(returnValue);
+ if (!isExistSharingContextID(currentContextId)) {
+ return;
+ }
+ updateSharingDataAtCurrentContextDataManager(currentContextId, sharingContextId);
+ insertSharingData();
+ }
+
+ private void insertContextOfEvasGL(GLES20LogData logData) {
+ String apiName = logData.getApiName();
+ String parameter = logData.getArgs();
+ String parameters[] = parameter.split(CommonConstants.COMMA + CommonConstants.SPACE);
+ String returnValue = logData.getReturn();
+ if (parameters.length != 2) {
- DA_LOG.error("GL context hash map not set data : " + sharingContextId);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ long currentContextId = AnalyzerUtil.addrToLong(returnValue);
+ long sharingContextId = AnalyzerUtil.addrToLong(parameters[1]);
+ if (!isExistSharingContextID(currentContextId)) {
+ return;
+ }
+ updateSharingDataAtCurrentContextDataManager(currentContextId, sharingContextId);
+ insertSharingData();
+ }
+
+ private boolean isExistSharingContextID(long currentContextId) {
+ if (currentContextId != 0) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private void updateSharingDataAtCurrentContextDataManager(long currentContextId,
+ long sharingContextId) {
+ getStateDataManager().updateStateAtCurrentContext(GLContextNameEnum.CONTEXT_ID.ordinal(),
+ sharingContextId);
+ GLContextDataManager curretnContextValue = getStateDataManager().getGLContextDataManager(
+ sharingContextId);
+ if (null == curretnContextValue) {
++ Logger.error("GL context hash map not set data : " + sharingContextId);
+ return;
+ }
+ curretnContextValue.addSharingContextID(getStateDataManager().getStateHashMap(),
+ currentContextId);
+ }
+
+ private void insertSharingData() {
+ List<GLSharingContextType> insertSharingInfoList = new ArrayList<GLSharingContextType>();
+ Set<Entry<Long, GLContextDataManager>> set = getStateDataManager().getStateHashMap()
+ .entrySet();
+ Iterator<Entry<Long, GLContextDataManager>> itr = set.iterator();
+ while (itr.hasNext()) {
+ Map.Entry<Long, GLContextDataManager> e = (Map.Entry<Long, GLContextDataManager>) itr
+ .next();
+ insertSharingInfoList.addAll(getInsertSharingInfoList(e.getValue()));
+ }
+ GLDataManager.getInstance().getStateSharingDBTableManage()
+ .insertSharingData(insertSharingInfoList);
+ }
+
+ private List<GLSharingContextType> getInsertSharingInfoList(GLContextDataManager contextValue) {
+ List<GLSharingContextType> returnSharingInfoList = new ArrayList<GLSharingContextType>();
+ for (int i = 0; i < contextValue.sharingContextIdList.size(); i++) {
+ returnSharingInfoList.add(new GLSharingContextType(contextValue.contextID,
+ contextValue.sharingContextIdList.get(i)));
+ }
+ return returnSharingInfoList;
+ }
+}
--- /dev/null
- import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * Sanghyun Lee <sanghyunnim.lee@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * 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.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.opengl.data;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
- import org.tizen.dynamicanalyzer.util.DALogger;
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
++import org.tizen.dynamicanalyzer.project.FunctionNameManager;
+import org.tizen.dynamicanalyzer.swap.model.data.GLES20LogData;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLRedundantDataType;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLStatisticsDataType;
- String hashKey = AnalyzerManager.getProject().getApiName(data.getApiID())
++import org.tizen.dynamicanalyzer.util.Logger;
+
+public class GLStatisticsDataManager {
+ private static final String SPLIT = CommonConstants.SPACE + CommonConstants.CMD_SPLIT
+ + CommonConstants.SPACE;
+ private static final String STATE_CHANGE = "State Change";//$NON-NLS-1$
+ private static final String MATRIX = "Matrix";//$NON-NLS-1$
+ private static final String TEXTURE = "Texture";//$NON-NLS-1$
+ private static final String DRAW = "Draw";//$NON-NLS-1$
+ private static final String PROGRAM_AND_SHADER = "Program and Shader";//$NON-NLS-1$
+ private static final String BUFFER = "Buffer";//$NON-NLS-1$
+ private static final String GET = "Get";//$NON-NLS-1$
+ private static final String IS = "Is";//$NON-NLS-1$
+ private static final String DELETE = "Delete";//$NON-NLS-1$
+ private static final String BIND = "Bind";//$NON-NLS-1$
+ private static final String EVAS_GL = "evas_gl";//$NON-NLS-1$
+ private ConcurrentHashMap<String, GLRedundantDataType> redundantHsahMap = new ConcurrentHashMap<String, GLRedundantDataType>();
+ private double totalAPICount = 0;
+
+ public void addAPI(GLES20LogData logData) {
+ String hashKey = logData.getApiName() + logData.getArgs();
+ GLRedundantDataType savedHash = redundantHsahMap.get(hashKey);
+ if (null == savedHash) {
+ redundantHsahMap.put(
+ hashKey,
+ new GLRedundantDataType(logData.getApiId(), logData.getArgs(), 1, logData
+ .getElapsedTime()));
+ } else {
+ savedHash.addCallCount();
+ savedHash.addElapsedTime(logData.getElapsedTime());
+ }
+ totalAPICount++;
+ }
+
+ public void insertRedundantData() {
+ GLDataManager.getInstance().getRedundantDBTable()
+ .insertRedundantData(getRedundantTableData());
+ }
+
+ public void selectRedundantData() {
+ List<GLRedundantDataType> redundantList = GLDataManager.getInstance().getRedundantDBTable()
+ .select();
+ for (GLRedundantDataType data : redundantList) {
- DALogger.getInstance().error("Not Define API Type of Statistics : " + apiName);
++ String hashKey = FunctionNameManager.getFunctionName(data.getApiID())
+ + data.getArgs();
+ GLRedundantDataType savedHash = redundantHsahMap.get(hashKey);
+ if (null == savedHash) {
+ redundantHsahMap.put(
+ hashKey,
+ new GLRedundantDataType(data.getApiID(), data.getArgs(), data
+ .getCallCount(), data.getElapsedTime()));
+ } else {
+ savedHash.setCallCount(savedHash.getCallCount() + data.getCallCount());
+ }
+ totalAPICount += data.getCallCount();
+ }
+ }
+
+ public List<GLRedundantDataType> getRedundantTableData() {
+ List<GLRedundantDataType> returnList = new ArrayList<GLRedundantDataType>();
+ for (Map.Entry<String, GLRedundantDataType> entry : redundantHsahMap.entrySet()) {
+ returnList.add(entry.getValue());
+ }
+ return returnList;
+ }
+
+ public List<GLStatisticsDataType> getStatisticsTableData() {
+ List<GLStatisticsDataType> returnList = new ArrayList<GLStatisticsDataType>();
+ LinkedHashMap<String, GLStatisticsDataType> statisticsHashMap = getStatisticDataFromRedundantHashMap();
+ for (Map.Entry<String, GLStatisticsDataType> entry : statisticsHashMap.entrySet()) {
+ returnList.add(entry.getValue());
+ }
+ return returnList;
+ }
+
+ private LinkedHashMap<String, GLStatisticsDataType> getStatisticDataFromRedundantHashMap() {
+ LinkedHashMap<String, GLStatisticsDataType> returnStatisticsHsahMap = new LinkedHashMap<String, GLStatisticsDataType>();
+ for (Map.Entry<String, GLRedundantDataType> entry : redundantHsahMap.entrySet()) {
+ GLRedundantDataType redundantDataType = entry.getValue();
+ String hashKey = redundantDataType.getAPIName();
+ GLStatisticsDataType savedHash = returnStatisticsHsahMap.get(hashKey);
+ if (null == savedHash) {
+ returnStatisticsHsahMap.put(
+ hashKey,
+ new GLStatisticsDataType(redundantDataType.getApiID(), redundantDataType
+ .getArgs(), getRate(redundantDataType.getCallCount()),
+ redundantDataType.getCallCount(), redundantDataType
+ .getElapsedTime(), getAPIType(redundantDataType
+ .getAPIName())));
+ } else {
+ savedHash.addCallCount(redundantDataType.getCallCount());
+ savedHash.setRate(getRate(savedHash.getCallCount()));
+ savedHash.addElapsedTime(redundantDataType.getElapsedTime());
+ }
+ }
+ return returnStatisticsHsahMap;
+ }
+
+ private double getRate(double callCount) {
+ return callCount / totalAPICount * 100;
+ }
+
+ private String getAPIType(String apiName) {
+ StringBuffer returnBuffer = new StringBuffer();
+ if (apiName.contains(MATRIX)) {
+ returnBuffer.append(MATRIX).append(SPLIT);
+ }
+ if (apiName.contains(TEXTURE) || apiName.contains("Tex")) {//$NON-NLS-1$
+ returnBuffer.append(TEXTURE).append(SPLIT);
+ }
+ if (apiName.contains(BUFFER)) {
+ returnBuffer.append(BUFFER).append(SPLIT);
+ }
+ if (apiName.contains(GET) || apiName.contains("glHint")) {//$NON-NLS-1$
+ returnBuffer.append(GET).append(SPLIT);
+ }
+ if (apiName.contains(IS)) {
+ returnBuffer.append(IS).append(SPLIT);
+ }
+ if (apiName.contains(DRAW) || apiName.contains("glFinish") || apiName.contains("glFlush")) {//$NON-NLS-1$//$NON-NLS-2$
+ returnBuffer.append(DRAW).append(SPLIT);
+ }
+ if (apiName.contains(DELETE)) {
+ returnBuffer.append(DELETE).append(SPLIT);
+ }
+ if (apiName.contains("Bind") || apiName.contains("Gen")) {//$NON-NLS-1$//$NON-NLS-2$
+ returnBuffer.append(BIND).append(SPLIT);
+ }
+ if (apiName.contains("Program") || apiName.contains("Shader")//$NON-NLS-1$//$NON-NLS-2$
+ || apiName.contains("Uniform") || apiName.contains("Vertex")) {//$NON-NLS-1$//$NON-NLS-2$
+ returnBuffer.append(PROGRAM_AND_SHADER).append(SPLIT);
+ }
+ if (apiName.contains("Blend") || apiName.contains("Clear") || apiName.contains("Color")//$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
+ || apiName.contains("Cull") || apiName.contains("Depth")//$NON-NLS-1$//$NON-NLS-2$
+ || apiName.contains("Disable") || apiName.contains("Enable")//$NON-NLS-1$//$NON-NLS-2$
+ || apiName.contains("Stencil") || apiName.contains("glLineWidth")//$NON-NLS-1$//$NON-NLS-2$
+ || apiName.contains("glPixelStorei") || apiName.contains("glPolygonOffset")//$NON-NLS-1$//$NON-NLS-2$
+ || apiName.contains("glReadPixels") || apiName.contains("glSampleCoverage")//$NON-NLS-1$//$NON-NLS-2$
+ || apiName.contains("glScissor") || apiName.contains("glViewport")) {//$NON-NLS-1$//$NON-NLS-2$
+ returnBuffer.append(STATE_CHANGE).append(SPLIT);
+ }
+ if (apiName.contains(EVAS_GL)) {
+ returnBuffer.append(EVAS_GL);
+ }
+ if (returnBuffer.length() == 0) {
++ Logger.error("Not Define API Type of Statistics : " + apiName);
+ return CommonConstants.EMPTY;
+ }
+ if (returnBuffer.lastIndexOf(SPLIT) == returnBuffer.length() - SPLIT.length()) {
+ returnBuffer.delete(returnBuffer.length() - SPLIT.length(), returnBuffer.length());
+ }
+ return returnBuffer.toString();
+ }
+}
--- /dev/null
- import org.tizen.dynamicanalyzer.util.DALogger;
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * Sanghyun Lee <sanghyunnim.lee@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * 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.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.opengl.data;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
+import org.tizen.dynamicanalyzer.swap.model.data.GLES20LogData;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLAPINameDefine;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLContextNameEnum;
+import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLStateTextureType;
- private static final DALogger DA_LOG = DALogger.getInstance();
++import org.tizen.dynamicanalyzer.util.Logger;
+
+public class GLTextureStateDataMaker {
- DA_LOG.error("GL extract API parameter : " + apiName);
+ private GLStateDataManager glStateDataManager = null;
+
+ public GLTextureStateDataMaker(GLStateDataManager glStateDataManager) {
+ this.glStateDataManager = glStateDataManager;
+ }
+
+ private GLStateDataManager getStateDataManager() {
+ return this.glStateDataManager;
+ }
+
+ public void extractGLTextureAPIParameter(GLES20LogData logData) {
+ if (glStateDataManager.isNormalAPIStatusForExtractParameter(logData)) {
+ String apiName = logData.getApiName();
+ String parameter = logData.getArgs();
+ long contextId = logData.getCurrentContextID();
+ String parameters[] = parameter.split(CommonConstants.COMMA + CommonConstants.SPACE);
+ String contextValues[] = logData.getContextValue().trim().split(CommonConstants.COMMA);
+ GLContextDataManager curretnContextValue = getStateDataManager()
+ .getGLContextDataManager(contextId);
+
+ if (apiName.equals(GLAPINameDefine.API_GL_TEXTURE_ACTIVE)) {
+ if (parameters.length != 1) {
- DA_LOG.error("GL extract API parameter : " + apiName);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ getStateDataManager()
+ .updateStateAtCurrentContext(GLContextNameEnum.TEXTURE_ACTIVE.ordinal(),
+ Integer.parseInt(parameters[0]));
+ } else if (apiName.equals(GLAPINameDefine.API_GL_TEXTURE_GEN)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + apiName);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ for (int i = 0; i < Integer.parseInt(parameters[0]); i++) {
+ curretnContextValue.textureList.add(new GLStateTextureType(Integer
+ .parseInt(contextValues[i].trim()), contextId, logData.getSeq()));
+ }
+ } else if (apiName.equals(GLAPINameDefine.API_GL_TEXTURE_BIND)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + apiName);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ for (int i = 0; i < curretnContextValue.textureList.size(); i++) {
+ if (isSameTextureType(curretnContextValue.textureList.get(i), parameters[1],
+ contextId)) {
+ curretnContextValue.textureList.get(i).setType(
+ Integer.parseInt(parameters[0].trim()));
+ break;
+ }
+ }
+ } else if (apiName.equals(GLAPINameDefine.API_GL_TEXTURE_DEL)) {
+ if (parameters.length != 2) {
- DA_LOG.error("GL extract API parameter : " + apiName);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ for (int i = 0; i < Integer.parseInt(parameters[0]); i++) {
+ for (int j = 0; j < curretnContextValue.textureList.size(); j++) {
+ if (isSameTextureType(curretnContextValue.textureList.get(j),
+ parameters[0], contextId)) {
+ curretnContextValue.textureList.get(j).setType(
+ Integer.parseInt(parameters[0].trim()));
+ break;
+ }
+ }
+ }
+ } else if (apiName.equals(GLAPINameDefine.API_GL_TEXTURE_PARAM_F)
+ || apiName.equals(GLAPINameDefine.API_GL_TEXTURE_PARAM_I)) {
+ if (parameters.length != 3) {
- DA_LOG.error("GL " + apiName + " undefine type : " + parameters[1]);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ for (int i = 0; i < curretnContextValue.textureList.size(); i++) {
+ if (curretnContextValue.textureList.get(i).getContextID() != contextId) {
+ continue;
+ }
+ if (curretnContextValue.textureList.get(i).getType() != Integer
+ .parseInt(parameters[0].trim())) {
+ continue;
+ }
+ if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_MAG_FILTER)) {
+ curretnContextValue.textureList.get(i).setMagFilter(
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_MIN_FILTER)) {
+ curretnContextValue.textureList.get(i).setMinFilter(
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_WRAP_S)) {
+ curretnContextValue.textureList.get(i).setWrapS(
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_WRAP_T)) {
+ curretnContextValue.textureList.get(i).setWrapT(
+ Integer.parseInt(parameters[2]));
+ } else {
- DA_LOG.error("GL extract API parameter : " + apiName);
++ Logger.error("GL " + apiName + " undefine type : " + parameters[1]);
+ }
+ }
+ } else if (apiName.equals(GLAPINameDefine.API_GL_TEXTURE_PARAM_FV)
+ || apiName.equals(GLAPINameDefine.API_GL_TEXTURE_PARAM_IV)) {
+ if (parameters.length != 3) {
- DA_LOG.error("GL " + apiName + " undefine type : " + parameters[1]);
++ Logger.error("GL extract API parameter : " + apiName);
+ return;
+ }
+ for (int i = 0; i < curretnContextValue.textureList.size(); i++) {
+ if (curretnContextValue.textureList.get(i).getObjID() != Integer
+ .parseInt(parameters[0].trim())
+ || curretnContextValue.textureList.get(i).getContextID() != contextId) {
+ continue;
+ }
+ if (curretnContextValue.textureList.get(i).getType() != Integer
+ .parseInt(parameters[0].trim())) {
+ continue;
+ }
+ if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_MAG_FILTER)) {
+ curretnContextValue.textureList.get(i).setMagFilter(
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_MIN_FILTER)) {
+ curretnContextValue.textureList.get(i).setMinFilter(
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_WRAP_S)) {
+ curretnContextValue.textureList.get(i).setWrapS(
+ Integer.parseInt(parameters[2]));
+ } else if (parameters[1].equals(GLAPINameDefine.GL_TEXTURE_WRAP_T)) {
+ curretnContextValue.textureList.get(i).setWrapT(
+ Integer.parseInt(parameters[2]));
+ } else {
++ Logger.error("GL " + apiName + " undefine type : " + parameters[1]);
+ }
+ }
+ }
+ }
+ }
+
+ public void addTextureList(GLStateTextureType textureType) {
+ GLContextDataManager contextValue = getStateDataManager().getGLContextDataManager(
+ textureType.getContextID());
+ if (null == contextValue) {
+ contextValue = new GLContextDataManager(textureType.getContextID());
+ getStateDataManager().getStateHashMap().put(textureType.getContextID(), contextValue);
+ }
+ contextValue.textureList.add(textureType);
+ }
+
+ public List<GLStateTextureType> getTextureList() {
+ List<GLStateTextureType> returnProgramList = new ArrayList<GLStateTextureType>();
+ for (Map.Entry<Long, GLContextDataManager> entry : getStateDataManager().getStateHashMap()
+ .entrySet()) {
+ returnProgramList.addAll(entry.getValue().textureList);
+ }
+ return returnProgramList;
+ }
+
+ private boolean isSameTextureType(GLStateTextureType existingTexture,
+ String parameterTextureObjId, long contextId) {
+ if (existingTexture.getObjID() == Integer.parseInt(parameterTextureObjId.trim())
+ && existingTexture.getContextID() == contextId) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+}
--- /dev/null
- import org.tizen.dynamicanalyzer.common.AnalyzerManager;
+/*
+ * Dynamic Analyzer
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:
+ * Hyunjong Park <phjwithyou.park@samsung.com>
+ * Juyoung Kim <j0.kim@samsung.com>
+ *
+ * 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.
+ *
+ * Contributors:
+ * - S-Core Co., Ltd
+ *
+ */
+
+package org.tizen.dynamicanalyzer.ui.opengl.data.type;
+
- return AnalyzerManager.getProject().getApiName(apiID);
+import org.tizen.dynamicanalyzer.constant.CommonConstants;
++import org.tizen.dynamicanalyzer.project.FunctionNameManager;
+
+public class GLRedundantDataType {
+ private int apiID = -1;
+ private String args = CommonConstants.EMPTY;
+ private int callCount = -1;
+ private long elapsedTime = 0;
+
+ public GLRedundantDataType(int apiID, String args, int callCount, long elapsedTime) {
+ this.apiID = apiID;
+ this.args = args;
+ this.elapsedTime = elapsedTime;
+ this.callCount = callCount;
+ }
+
+ public int getApiID() {
+ return apiID;
+ }
+
+ public String getAPIName() {
++ return FunctionNameManager.getFunctionName(apiID);
+ }
+
+ public void setApiID(int apiID) {
+ this.apiID = apiID;
+ }
+
+ public String getArgs() {
+ return args;
+ }
+
+ public void setArgs(String args) {
+ this.args = args;
+ }
+
+ public int getCallCount() {
+ return callCount;
+ }
+
+ public void addCallCount() {
+ callCount++;
+ }
+
+ public void addCallCount(int preCallCount) {
+ callCount += preCallCount;
+ }
+
+ public void setCallCount(int callCount) {
+ this.callCount = callCount;
+ }
+
+ public long getElapsedTime() {
+ return elapsedTime;
+ }
+
+ public void setElapsedTime(long elapsedTime) {
+ this.elapsedTime = elapsedTime;
+ }
+
+ public void addElapsedTime(long elapsedTime) {
+ this.elapsedTime += elapsedTime;
+ }
+}
import org.tizen.dynamicanalyzer.ui.opengl.data.type.GLSelectionData;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableComposite;
import org.tizen.dynamicanalyzer.ui.widgets.table.DATableDataFormat;
- import org.tizen.dynamicanalyzer.util.DALogger;
++import org.tizen.dynamicanalyzer.util.Logger;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButton;
import org.tizen.dynamicanalyzer.widgets.button.DACustomButtonClickEventListener;
}
List<String> text = new ArrayList<String>();
- DATableDataFormat tableData = new DATableDataFormat(
- Long.parseLong(selectedSeq));
+ DATableDataFormat tableData = new DATableDataFormat(Long.parseLong(selectedSeq));
String stateName = dbManager.getColumnName()[i];
- String defaultState = GLContextDefaultValueHashMap
- .getDefaultValue(stateName);
+ Object defaultValue = GLContextDefaultValueHashMap.getDefaultValue(stateName);
+ Object currentValue = stateValueList.get(i);
+
+ String defatueState = CommonConstants.EMPTY;
+ String currenteState = CommonConstants.EMPTY;
+
+ if (GLDataManager.getInstance().getContextDBTableManage().isIntegerType(i)) {
+ defatueState = Integer.toString((Integer) defaultValue);
+ if (null == currentValue) {
+ currenteState = defatueState;
+ } else {
+ currenteState = Integer.toString((Integer) currentValue);
+ }
+
+ } else if (GLDataManager.getInstance().getContextDBTableManage().isLongType(i)) {
+ defatueState = Long.toString((Long) defaultValue);
+ if (null == currentValue) {
+ currenteState = defatueState;
+ } else {
+ currenteState = Long.toString((Long) currentValue);
+ }
+ } else if (GLDataManager.getInstance().getContextDBTableManage().isBooleans(i)) {
+ defatueState = Boolean.toString((Boolean) defaultValue);
+ if (null == currentValue) {
+ currenteState = defatueState;
+ } else {
+ currenteState = Boolean.toString((Boolean) currentValue);
+ }
+ } else if (GLDataManager.getInstance().getContextDBTableManage().isStringType(i)) {
+ defatueState = (String) defaultValue;
+ if (null == currentValue) {
+ currenteState = defatueState;
+ } else {
+ currenteState = (String) currentValue;
+ }
+ } else if (GLDataManager.getInstance().getContextDBTableManage().isBooleanArray(i)
+ || GLDataManager.getInstance().getContextDBTableManage().isIntegerArray(i)
+ || GLDataManager.getInstance().getContextDBTableManage().isLongArray(i)) {
+ defatueState = "null";
+ if (null == currentValue) {
+ currenteState = defatueState;
+ } else {
+ currenteState = (String) currentValue.toString();
+ }
+ } else {
- DALogger.getInstance().error("undefine column : " + i);
++ Logger.error("undefine column : " + i);
+ }
- String currenteState = stateValueList.get(i);
- if (isCheckedBox
- && !isChangeStateValue(defaultState, currenteState)) {
+ if (isCheckedBox && !isChangeStateValue(defatueState, currenteState)) {
continue;
}
projects / sdk / tools / dynamic-analyzer.git / commitdiff