blob: f5681ce712d5803e8b33852afd2fe6e8a441eacb [file] [log] [blame]
/*
* 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.
*/
#include "LayerCache.h"
#include "Caches.h"
#include "Properties.h"
#include <utils/Log.h>
#include <GLES2/gl2.h>
namespace android {
namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
// Constructors/destructor
///////////////////////////////////////////////////////////////////////////////
LayerCache::LayerCache()
: mSize(0)
, mMaxSize(Properties::layerPoolSize) {}
LayerCache::~LayerCache() {
clear();
}
///////////////////////////////////////////////////////////////////////////////
// Size management
///////////////////////////////////////////////////////////////////////////////
size_t LayerCache::getCount() {
return mCache.size();
}
uint32_t LayerCache::getSize() {
return mSize;
}
uint32_t LayerCache::getMaxSize() {
return mMaxSize;
}
void LayerCache::setMaxSize(uint32_t maxSize) {
clear();
mMaxSize = maxSize;
}
///////////////////////////////////////////////////////////////////////////////
// Caching
///////////////////////////////////////////////////////////////////////////////
int LayerCache::LayerEntry::compare(const LayerCache::LayerEntry& lhs,
const LayerCache::LayerEntry& rhs) {
int deltaInt = int(lhs.mWidth) - int(rhs.mWidth);
if (deltaInt != 0) return deltaInt;
return int(lhs.mHeight) - int(rhs.mHeight);
}
void LayerCache::deleteLayer(Layer* layer) {
if (layer) {
LAYER_LOGD("Destroying layer %dx%d, fbo %d", layer->getWidth(), layer->getHeight(),
layer->getFbo());
mSize -= layer->getWidth() * layer->getHeight() * 4;
layer->state = Layer::State::DeletedFromCache;
layer->decStrong(nullptr);
}
}
void LayerCache::clear() {
for (auto entry : mCache) {
deleteLayer(entry.mLayer);
}
mCache.clear();
}
Layer* LayerCache::get(RenderState& renderState, const uint32_t width, const uint32_t height) {
Layer* layer = nullptr;
LayerEntry entry(width, height);
auto iter = mCache.find(entry);
if (iter != mCache.end()) {
entry = *iter;
mCache.erase(iter);
layer = entry.mLayer;
layer->state = Layer::State::RemovedFromCache;
mSize -= layer->getWidth() * layer->getHeight() * 4;
LAYER_LOGD("Reusing layer %dx%d", layer->getWidth(), layer->getHeight());
} else {
LAYER_LOGD("Creating new layer %dx%d", entry.mWidth, entry.mHeight);
layer = new Layer(Layer::Type::DisplayList, renderState, entry.mWidth, entry.mHeight);
layer->setBlend(true);
layer->generateTexture();
layer->bindTexture();
layer->setFilter(GL_NEAREST);
layer->setWrap(GL_CLAMP_TO_EDGE, false);
#if DEBUG_LAYERS
dump();
#endif
}
return layer;
}
void LayerCache::dump() {
for (auto entry : mCache) {
ALOGD(" Layer size %dx%d", entry.mWidth, entry.mHeight);
}
}
bool LayerCache::put(Layer* layer) {
if (!layer->isCacheable()) return false;
const uint32_t size = layer->getWidth() * layer->getHeight() * 4;
// Don't even try to cache a layer that's bigger than the cache
if (size < mMaxSize) {
// TODO: Use an LRU
while (mSize + size > mMaxSize) {
Layer* victim = mCache.begin()->mLayer;
deleteLayer(victim);
mCache.erase(mCache.begin());
LAYER_LOGD(" Deleting layer %.2fx%.2f", victim->layer.getWidth(),
victim->layer.getHeight());
}
layer->cancelDefer();
LayerEntry entry(layer);
mCache.insert(entry);
mSize += size;
layer->state = Layer::State::InCache;
return true;
}
layer->state = Layer::State::FailedToCache;
return false;
}
}; // namespace uirenderer
}; // namespace android