78dd96d5af
The counter can be enabled by setting the system property called debug.hwui.overdraw to the string "count". If the string is set to "show", overdraw will be highlighted on screen instead of printing out a simple counter. Change-Id: I9a9c970d54bffab43138bbb7682f6c04bc2c40bd
593 lines
17 KiB
C++
593 lines
17 KiB
C++
/*
|
|
* Copyright (C) 2010 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.
|
|
*/
|
|
|
|
#define LOG_TAG "OpenGLRenderer"
|
|
|
|
#include <utils/Log.h>
|
|
#include <utils/String8.h>
|
|
|
|
#include "Caches.h"
|
|
#include "DisplayListRenderer.h"
|
|
#include "Properties.h"
|
|
#include "LayerRenderer.h"
|
|
|
|
namespace android {
|
|
|
|
#ifdef USE_OPENGL_RENDERER
|
|
using namespace uirenderer;
|
|
ANDROID_SINGLETON_STATIC_INSTANCE(Caches);
|
|
#endif
|
|
|
|
namespace uirenderer {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Macros
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if DEBUG_CACHE_FLUSH
|
|
#define FLUSH_LOGD(...) ALOGD(__VA_ARGS__)
|
|
#else
|
|
#define FLUSH_LOGD(...)
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Constructors/destructor
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
Caches::Caches(): Singleton<Caches>(), mExtensions(Extensions::getInstance()), mInitialized(false) {
|
|
init();
|
|
initFont();
|
|
initConstraints();
|
|
initProperties();
|
|
initExtensions();
|
|
|
|
mDebugLevel = readDebugLevel();
|
|
ALOGD("Enabling debug mode %d", mDebugLevel);
|
|
}
|
|
|
|
bool Caches::init() {
|
|
if (mInitialized) return false;
|
|
|
|
glGenBuffers(1, &meshBuffer);
|
|
glBindBuffer(GL_ARRAY_BUFFER, meshBuffer);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(gMeshVertices), gMeshVertices, GL_STATIC_DRAW);
|
|
|
|
mCurrentBuffer = meshBuffer;
|
|
mCurrentIndicesBuffer = 0;
|
|
mCurrentPositionPointer = this;
|
|
mCurrentPositionStride = 0;
|
|
mCurrentTexCoordsPointer = this;
|
|
mCurrentPixelBuffer = 0;
|
|
|
|
mTexCoordsArrayEnabled = false;
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
scissorEnabled = false;
|
|
mScissorX = mScissorY = mScissorWidth = mScissorHeight = 0;
|
|
|
|
glActiveTexture(gTextureUnits[0]);
|
|
mTextureUnit = 0;
|
|
|
|
mRegionMesh = NULL;
|
|
mMeshIndices = 0;
|
|
|
|
blend = false;
|
|
lastSrcMode = GL_ZERO;
|
|
lastDstMode = GL_ZERO;
|
|
currentProgram = NULL;
|
|
|
|
mFunctorsCount = 0;
|
|
|
|
debugLayersUpdates = false;
|
|
debugOverdraw = false;
|
|
debugStencilClip = kStencilHide;
|
|
|
|
patchCache.init(*this);
|
|
|
|
mInitialized = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
void Caches::initFont() {
|
|
fontRenderer = GammaFontRenderer::createRenderer();
|
|
}
|
|
|
|
void Caches::initExtensions() {
|
|
if (mExtensions.hasDebugMarker()) {
|
|
eventMark = glInsertEventMarkerEXT;
|
|
|
|
startMark = glPushGroupMarkerEXT;
|
|
endMark = glPopGroupMarkerEXT;
|
|
} else {
|
|
eventMark = eventMarkNull;
|
|
startMark = startMarkNull;
|
|
endMark = endMarkNull;
|
|
}
|
|
|
|
if (mExtensions.hasDebugLabel() && (drawDeferDisabled || drawReorderDisabled)) {
|
|
setLabel = glLabelObjectEXT;
|
|
getLabel = glGetObjectLabelEXT;
|
|
} else {
|
|
setLabel = setLabelNull;
|
|
getLabel = getLabelNull;
|
|
}
|
|
}
|
|
|
|
void Caches::initConstraints() {
|
|
GLint maxTextureUnits;
|
|
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
|
|
if (maxTextureUnits < REQUIRED_TEXTURE_UNITS_COUNT) {
|
|
ALOGW("At least %d texture units are required!", REQUIRED_TEXTURE_UNITS_COUNT);
|
|
}
|
|
|
|
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
|
|
}
|
|
|
|
bool Caches::initProperties() {
|
|
bool prevDebugLayersUpdates = debugLayersUpdates;
|
|
bool prevDebugOverdraw = debugOverdraw;
|
|
StencilClipDebug prevDebugStencilClip = debugStencilClip;
|
|
|
|
char property[PROPERTY_VALUE_MAX];
|
|
if (property_get(PROPERTY_DEBUG_LAYERS_UPDATES, property, NULL) > 0) {
|
|
INIT_LOGD(" Layers updates debug enabled: %s", property);
|
|
debugLayersUpdates = !strcmp(property, "true");
|
|
} else {
|
|
debugLayersUpdates = false;
|
|
}
|
|
|
|
if (property_get(PROPERTY_DEBUG_OVERDRAW, property, NULL) > 0) {
|
|
INIT_LOGD(" Overdraw debug enabled: %s", property);
|
|
debugOverdraw = !strcmp(property, "show");
|
|
} else {
|
|
debugOverdraw = false;
|
|
}
|
|
|
|
// See Properties.h for valid values
|
|
if (property_get(PROPERTY_DEBUG_STENCIL_CLIP, property, NULL) > 0) {
|
|
INIT_LOGD(" Stencil clip debug enabled: %s", property);
|
|
if (!strcmp(property, "hide")) {
|
|
debugStencilClip = kStencilHide;
|
|
} else if (!strcmp(property, "highlight")) {
|
|
debugStencilClip = kStencilShowHighlight;
|
|
} else if (!strcmp(property, "region")) {
|
|
debugStencilClip = kStencilShowRegion;
|
|
}
|
|
} else {
|
|
debugStencilClip = kStencilHide;
|
|
}
|
|
|
|
if (property_get(PROPERTY_DISABLE_DRAW_DEFER, property, "false")) {
|
|
drawDeferDisabled = !strcasecmp(property, "true");
|
|
INIT_LOGD(" Draw defer %s", drawDeferDisabled ? "disabled" : "enabled");
|
|
} else {
|
|
INIT_LOGD(" Draw defer enabled");
|
|
}
|
|
|
|
if (property_get(PROPERTY_DISABLE_DRAW_REORDER, property, "false")) {
|
|
drawReorderDisabled = !strcasecmp(property, "true");
|
|
INIT_LOGD(" Draw reorder %s", drawReorderDisabled ? "disabled" : "enabled");
|
|
} else {
|
|
INIT_LOGD(" Draw reorder enabled");
|
|
}
|
|
|
|
return (prevDebugLayersUpdates != debugLayersUpdates) ||
|
|
(prevDebugOverdraw != debugOverdraw) ||
|
|
(prevDebugStencilClip != debugStencilClip);
|
|
}
|
|
|
|
void Caches::terminate() {
|
|
if (!mInitialized) return;
|
|
|
|
glDeleteBuffers(1, &meshBuffer);
|
|
mCurrentBuffer = 0;
|
|
|
|
glDeleteBuffers(1, &mMeshIndices);
|
|
delete[] mRegionMesh;
|
|
mMeshIndices = 0;
|
|
mRegionMesh = NULL;
|
|
|
|
fboCache.clear();
|
|
|
|
programCache.clear();
|
|
currentProgram = NULL;
|
|
|
|
assetAtlas.terminate();
|
|
|
|
patchCache.clear();
|
|
|
|
mInitialized = false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Debug
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Caches::dumpMemoryUsage() {
|
|
String8 stringLog;
|
|
dumpMemoryUsage(stringLog);
|
|
ALOGD("%s", stringLog.string());
|
|
}
|
|
|
|
void Caches::dumpMemoryUsage(String8 &log) {
|
|
log.appendFormat("Current memory usage / total memory usage (bytes):\n");
|
|
log.appendFormat(" TextureCache %8d / %8d\n",
|
|
textureCache.getSize(), textureCache.getMaxSize());
|
|
log.appendFormat(" LayerCache %8d / %8d\n",
|
|
layerCache.getSize(), layerCache.getMaxSize());
|
|
log.appendFormat(" RenderBufferCache %8d / %8d\n",
|
|
renderBufferCache.getSize(), renderBufferCache.getMaxSize());
|
|
log.appendFormat(" GradientCache %8d / %8d\n",
|
|
gradientCache.getSize(), gradientCache.getMaxSize());
|
|
log.appendFormat(" PathCache %8d / %8d\n",
|
|
pathCache.getSize(), pathCache.getMaxSize());
|
|
log.appendFormat(" TextDropShadowCache %8d / %8d\n", dropShadowCache.getSize(),
|
|
dropShadowCache.getMaxSize());
|
|
log.appendFormat(" PatchCache %8d / %8d\n",
|
|
patchCache.getSize(), patchCache.getMaxSize());
|
|
for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
|
|
const uint32_t size = fontRenderer->getFontRendererSize(i);
|
|
log.appendFormat(" FontRenderer %d %8d / %8d\n", i, size, size);
|
|
}
|
|
log.appendFormat("Other:\n");
|
|
log.appendFormat(" FboCache %8d / %8d\n",
|
|
fboCache.getSize(), fboCache.getMaxSize());
|
|
|
|
uint32_t total = 0;
|
|
total += textureCache.getSize();
|
|
total += layerCache.getSize();
|
|
total += renderBufferCache.getSize();
|
|
total += gradientCache.getSize();
|
|
total += pathCache.getSize();
|
|
total += dropShadowCache.getSize();
|
|
total += patchCache.getSize();
|
|
for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
|
|
total += fontRenderer->getFontRendererSize(i);
|
|
}
|
|
|
|
log.appendFormat("Total memory usage:\n");
|
|
log.appendFormat(" %d bytes, %.2f MB\n", total, total / 1024.0f / 1024.0f);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Memory management
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Caches::clearGarbage() {
|
|
textureCache.clearGarbage();
|
|
pathCache.clearGarbage();
|
|
|
|
Vector<DisplayList*> displayLists;
|
|
Vector<Layer*> layers;
|
|
|
|
{ // scope for the lock
|
|
Mutex::Autolock _l(mGarbageLock);
|
|
displayLists = mDisplayListGarbage;
|
|
layers = mLayerGarbage;
|
|
mDisplayListGarbage.clear();
|
|
mLayerGarbage.clear();
|
|
}
|
|
|
|
size_t count = displayLists.size();
|
|
for (size_t i = 0; i < count; i++) {
|
|
DisplayList* displayList = displayLists.itemAt(i);
|
|
delete displayList;
|
|
}
|
|
|
|
count = layers.size();
|
|
for (size_t i = 0; i < count; i++) {
|
|
Layer* layer = layers.itemAt(i);
|
|
delete layer;
|
|
}
|
|
layers.clear();
|
|
}
|
|
|
|
void Caches::deleteLayerDeferred(Layer* layer) {
|
|
Mutex::Autolock _l(mGarbageLock);
|
|
mLayerGarbage.push(layer);
|
|
}
|
|
|
|
void Caches::deleteDisplayListDeferred(DisplayList* displayList) {
|
|
Mutex::Autolock _l(mGarbageLock);
|
|
mDisplayListGarbage.push(displayList);
|
|
}
|
|
|
|
void Caches::flush(FlushMode mode) {
|
|
FLUSH_LOGD("Flushing caches (mode %d)", mode);
|
|
|
|
switch (mode) {
|
|
case kFlushMode_Full:
|
|
textureCache.clear();
|
|
patchCache.clear();
|
|
dropShadowCache.clear();
|
|
gradientCache.clear();
|
|
fontRenderer->clear();
|
|
dither.clear();
|
|
// fall through
|
|
case kFlushMode_Moderate:
|
|
fontRenderer->flush();
|
|
textureCache.flush();
|
|
pathCache.clear();
|
|
tasks.stop();
|
|
// fall through
|
|
case kFlushMode_Layers:
|
|
layerCache.clear();
|
|
renderBufferCache.clear();
|
|
break;
|
|
}
|
|
|
|
clearGarbage();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// VBO
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool Caches::bindMeshBuffer() {
|
|
return bindMeshBuffer(meshBuffer);
|
|
}
|
|
|
|
bool Caches::bindMeshBuffer(const GLuint buffer) {
|
|
if (mCurrentBuffer != buffer) {
|
|
glBindBuffer(GL_ARRAY_BUFFER, buffer);
|
|
mCurrentBuffer = buffer;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Caches::unbindMeshBuffer() {
|
|
if (mCurrentBuffer) {
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
mCurrentBuffer = 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Caches::bindIndicesBuffer(const GLuint buffer) {
|
|
if (mCurrentIndicesBuffer != buffer) {
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
|
|
mCurrentIndicesBuffer = buffer;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Caches::bindIndicesBuffer() {
|
|
if (!mMeshIndices) {
|
|
uint16_t* regionIndices = new uint16_t[REGION_MESH_QUAD_COUNT * 6];
|
|
for (int i = 0; i < REGION_MESH_QUAD_COUNT; i++) {
|
|
uint16_t quad = i * 4;
|
|
int index = i * 6;
|
|
regionIndices[index ] = quad; // top-left
|
|
regionIndices[index + 1] = quad + 1; // top-right
|
|
regionIndices[index + 2] = quad + 2; // bottom-left
|
|
regionIndices[index + 3] = quad + 2; // bottom-left
|
|
regionIndices[index + 4] = quad + 1; // top-right
|
|
regionIndices[index + 5] = quad + 3; // bottom-right
|
|
}
|
|
|
|
glGenBuffers(1, &mMeshIndices);
|
|
bool force = bindIndicesBuffer(mMeshIndices);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, REGION_MESH_QUAD_COUNT * 6 * sizeof(uint16_t),
|
|
regionIndices, GL_STATIC_DRAW);
|
|
|
|
delete[] regionIndices;
|
|
return force;
|
|
}
|
|
|
|
return bindIndicesBuffer(mMeshIndices);
|
|
}
|
|
|
|
bool Caches::unbindIndicesBuffer() {
|
|
if (mCurrentIndicesBuffer) {
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
|
mCurrentIndicesBuffer = 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// PBO
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool Caches::bindPixelBuffer(const GLuint buffer) {
|
|
if (mCurrentPixelBuffer != buffer) {
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
|
|
mCurrentPixelBuffer = buffer;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Caches::unbindPixelBuffer() {
|
|
if (mCurrentPixelBuffer) {
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
|
|
mCurrentPixelBuffer = 0;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Meshes and textures
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Caches::bindPositionVertexPointer(bool force, GLvoid* vertices, GLsizei stride) {
|
|
if (force || vertices != mCurrentPositionPointer || stride != mCurrentPositionStride) {
|
|
GLuint slot = currentProgram->position;
|
|
glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, stride, vertices);
|
|
mCurrentPositionPointer = vertices;
|
|
mCurrentPositionStride = stride;
|
|
}
|
|
}
|
|
|
|
void Caches::bindTexCoordsVertexPointer(bool force, GLvoid* vertices, GLsizei stride) {
|
|
if (force || vertices != mCurrentTexCoordsPointer || stride != mCurrentTexCoordsStride) {
|
|
GLuint slot = currentProgram->texCoords;
|
|
glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, stride, vertices);
|
|
mCurrentTexCoordsPointer = vertices;
|
|
mCurrentTexCoordsStride = stride;
|
|
}
|
|
}
|
|
|
|
void Caches::resetVertexPointers() {
|
|
mCurrentPositionPointer = this;
|
|
mCurrentTexCoordsPointer = this;
|
|
}
|
|
|
|
void Caches::resetTexCoordsVertexPointer() {
|
|
mCurrentTexCoordsPointer = this;
|
|
}
|
|
|
|
void Caches::enableTexCoordsVertexArray() {
|
|
if (!mTexCoordsArrayEnabled) {
|
|
glEnableVertexAttribArray(Program::kBindingTexCoords);
|
|
mCurrentTexCoordsPointer = this;
|
|
mTexCoordsArrayEnabled = true;
|
|
}
|
|
}
|
|
|
|
void Caches::disableTexCoordsVertexArray() {
|
|
if (mTexCoordsArrayEnabled) {
|
|
glDisableVertexAttribArray(Program::kBindingTexCoords);
|
|
mTexCoordsArrayEnabled = false;
|
|
}
|
|
}
|
|
|
|
void Caches::activeTexture(GLuint textureUnit) {
|
|
if (mTextureUnit != textureUnit) {
|
|
glActiveTexture(gTextureUnits[textureUnit]);
|
|
mTextureUnit = textureUnit;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Scissor
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool Caches::setScissor(GLint x, GLint y, GLint width, GLint height) {
|
|
if (scissorEnabled && (x != mScissorX || y != mScissorY ||
|
|
width != mScissorWidth || height != mScissorHeight)) {
|
|
|
|
if (x < 0) {
|
|
width += x;
|
|
x = 0;
|
|
}
|
|
if (y < 0) {
|
|
height += y;
|
|
y = 0;
|
|
}
|
|
if (width < 0) {
|
|
width = 0;
|
|
}
|
|
if (height < 0) {
|
|
height = 0;
|
|
}
|
|
glScissor(x, y, width, height);
|
|
|
|
mScissorX = x;
|
|
mScissorY = y;
|
|
mScissorWidth = width;
|
|
mScissorHeight = height;
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Caches::enableScissor() {
|
|
if (!scissorEnabled) {
|
|
glEnable(GL_SCISSOR_TEST);
|
|
scissorEnabled = true;
|
|
resetScissor();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Caches::disableScissor() {
|
|
if (scissorEnabled) {
|
|
glDisable(GL_SCISSOR_TEST);
|
|
scissorEnabled = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Caches::setScissorEnabled(bool enabled) {
|
|
if (scissorEnabled != enabled) {
|
|
if (enabled) glEnable(GL_SCISSOR_TEST);
|
|
else glDisable(GL_SCISSOR_TEST);
|
|
scissorEnabled = enabled;
|
|
}
|
|
}
|
|
|
|
void Caches::resetScissor() {
|
|
mScissorX = mScissorY = mScissorWidth = mScissorHeight = 0;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Tiling
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Caches::startTiling(GLuint x, GLuint y, GLuint width, GLuint height, bool discard) {
|
|
if (mExtensions.hasTiledRendering() && !debugOverdraw) {
|
|
glStartTilingQCOM(x, y, width, height, (discard ? GL_NONE : GL_COLOR_BUFFER_BIT0_QCOM));
|
|
}
|
|
}
|
|
|
|
void Caches::endTiling() {
|
|
if (mExtensions.hasTiledRendering() && !debugOverdraw) {
|
|
glEndTilingQCOM(GL_COLOR_BUFFER_BIT0_QCOM);
|
|
}
|
|
}
|
|
|
|
bool Caches::hasRegisteredFunctors() {
|
|
return mFunctorsCount > 0;
|
|
}
|
|
|
|
void Caches::registerFunctors(uint32_t functorCount) {
|
|
mFunctorsCount += functorCount;
|
|
}
|
|
|
|
void Caches::unregisterFunctors(uint32_t functorCount) {
|
|
if (functorCount > mFunctorsCount) {
|
|
mFunctorsCount = 0;
|
|
} else {
|
|
mFunctorsCount -= functorCount;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Regions
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TextureVertex* Caches::getRegionMesh() {
|
|
// Create the mesh, 2 triangles and 4 vertices per rectangle in the region
|
|
if (!mRegionMesh) {
|
|
mRegionMesh = new TextureVertex[REGION_MESH_QUAD_COUNT * 4];
|
|
}
|
|
|
|
return mRegionMesh;
|
|
}
|
|
|
|
}; // namespace uirenderer
|
|
}; // namespace android
|