PathCache.cpp revision e190aa69756aecfaffabdd4c6d32cb6b3220d842 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "OpenGLRenderer"
18
19#include <GLES2/gl2.h>
20
21#include <SkCanvas.h>
22#include <SkRect.h>
23
24#include <utils/threads.h>
25
26#include "PathCache.h"
27#include "Properties.h"
28
29namespace android {
30namespace uirenderer {
31
32///////////////////////////////////////////////////////////////////////////////
33// Constructors/destructor
34///////////////////////////////////////////////////////////////////////////////
35
36PathCache::PathCache():
37        mCache(GenerationCache<PathCacheEntry, PathTexture*>::kUnlimitedCapacity),
38        mSize(0), mMaxSize(MB(DEFAULT_PATH_CACHE_SIZE)) {
39    char property[PROPERTY_VALUE_MAX];
40    if (property_get(PROPERTY_PATH_CACHE_SIZE, property, NULL) > 0) {
41        LOGD("  Setting path cache size to %sMB", property);
42        setMaxSize(MB(atof(property)));
43    } else {
44        LOGD("  Using default path cache size of %.2fMB", DEFAULT_PATH_CACHE_SIZE);
45    }
46    init();
47}
48
49PathCache::PathCache(uint32_t maxByteSize):
50        mCache(GenerationCache<PathCacheEntry, PathTexture*>::kUnlimitedCapacity),
51        mSize(0), mMaxSize(maxByteSize) {
52    init();
53}
54
55PathCache::~PathCache() {
56    Mutex::Autolock _l(mLock);
57    mCache.clear();
58}
59
60void PathCache::init() {
61    mCache.setOnEntryRemovedListener(this);
62
63    GLint maxTextureSize;
64    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
65    mMaxTextureSize = maxTextureSize;
66
67    mDebugEnabled = readDebugLevel() & kDebugCaches;
68}
69
70///////////////////////////////////////////////////////////////////////////////
71// Size management
72///////////////////////////////////////////////////////////////////////////////
73
74uint32_t PathCache::getSize() {
75    Mutex::Autolock _l(mLock);
76    return mSize;
77}
78
79uint32_t PathCache::getMaxSize() {
80    Mutex::Autolock _l(mLock);
81    return mMaxSize;
82}
83
84void PathCache::setMaxSize(uint32_t maxSize) {
85    Mutex::Autolock _l(mLock);
86    mMaxSize = maxSize;
87    while (mSize > mMaxSize) {
88        mCache.removeOldest();
89    }
90}
91
92///////////////////////////////////////////////////////////////////////////////
93// Callbacks
94///////////////////////////////////////////////////////////////////////////////
95
96void PathCache::operator()(PathCacheEntry& path, PathTexture*& texture) {
97    if (texture) {
98        const uint32_t size = texture->width * texture->height;
99        mSize -= size;
100
101        PATH_LOGD("PathCache::callback: delete path: name, size, mSize = %d, %d, %d",
102                texture->id, size, mSize);
103        if (mDebugEnabled) {
104            LOGD("Path deleted, size = %d", size);
105        }
106
107        glDeleteTextures(1, &texture->id);
108        delete texture;
109    }
110}
111
112///////////////////////////////////////////////////////////////////////////////
113// Caching
114///////////////////////////////////////////////////////////////////////////////
115
116void PathCache::remove(SkPath* path) {
117    Mutex::Autolock _l(mLock);
118
119    // TODO: Linear search...
120    Vector<uint32_t> pathsToRemove;
121    for (uint32_t i = 0; i < mCache.size(); i++) {
122        if (mCache.getKeyAt(i).path == path) {
123            pathsToRemove.push(i);
124        }
125    }
126
127    for (size_t i = 0; i < pathsToRemove.size(); i++) {
128        mCache.removeAt(pathsToRemove.itemAt(i));
129    }
130}
131
132PathTexture* PathCache::get(SkPath* path, SkPaint* paint) {
133    PathCacheEntry entry(path, paint);
134
135    mLock.lock();
136    PathTexture* texture = mCache.get(entry);
137    mLock.unlock();
138
139    if (!texture) {
140        texture = addTexture(entry, path, paint);
141    } else if (path->getGenerationID() != texture->generation) {
142        mLock.lock();
143        mCache.remove(entry);
144        mLock.unlock();
145        texture = addTexture(entry, path, paint);
146    }
147
148    return texture;
149}
150
151PathTexture* PathCache::addTexture(const PathCacheEntry& entry,
152        const SkPath *path, const SkPaint* paint) {
153    const SkRect& bounds = path->getBounds();
154
155    const float pathWidth = fmax(bounds.width(), 1.0f);
156    const float pathHeight = fmax(bounds.height(), 1.0f);
157
158    if (pathWidth > mMaxTextureSize || pathHeight > mMaxTextureSize) {
159        LOGW("Path too large to be rendered into a texture");
160        return NULL;
161    }
162
163    const float offset = entry.strokeWidth * 1.5f;
164    const uint32_t width = uint32_t(pathWidth + offset * 2.0 + 0.5);
165    const uint32_t height = uint32_t(pathHeight + offset * 2.0 + 0.5);
166
167    const uint32_t size = width * height;
168    // Don't even try to cache a bitmap that's bigger than the cache
169    if (size < mMaxSize) {
170        mLock.lock();
171        while (mSize + size > mMaxSize) {
172            mCache.removeOldest();
173        }
174        mLock.unlock();
175    }
176
177    PathTexture* texture = new PathTexture;
178    texture->left = bounds.fLeft;
179    texture->top = bounds.fTop;
180    texture->offset = offset;
181    texture->width = width;
182    texture->height = height;
183    texture->generation = path->getGenerationID();
184
185    SkBitmap bitmap;
186    bitmap.setConfig(SkBitmap::kA8_Config, width, height);
187    bitmap.allocPixels();
188    bitmap.eraseColor(0);
189
190    SkPaint pathPaint(*paint);
191    if (!pathPaint.getXfermode()) {
192        SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrc_Mode);
193        pathPaint.setXfermode(mode)->safeUnref();
194    }
195
196    SkCanvas canvas(bitmap);
197    canvas.translate(-bounds.fLeft + offset, -bounds.fTop + offset);
198    canvas.drawPath(*path, pathPaint);
199
200    generateTexture(bitmap, texture);
201
202    if (size < mMaxSize) {
203        mLock.lock();
204        mSize += size;
205        PATH_LOGD("PathCache::get: create path: name, size, mSize = %d, %d, %d",
206                texture->id, size, mSize);
207        if (mDebugEnabled) {
208            LOGD("Path created, size = %d", size);
209        }
210        mCache.put(entry, texture);
211        mLock.unlock();
212    } else {
213        texture->cleanup = true;
214    }
215
216    return texture;
217}
218
219void PathCache::clear() {
220    Mutex::Autolock _l(mLock);
221    mCache.clear();
222}
223
224void PathCache::generateTexture(SkBitmap& bitmap, Texture* texture) {
225    SkAutoLockPixels alp(bitmap);
226    if (!bitmap.readyToDraw()) {
227        LOGE("Cannot generate texture from bitmap");
228        return;
229    }
230
231    glGenTextures(1, &texture->id);
232
233    glBindTexture(GL_TEXTURE_2D, texture->id);
234    // Textures are Alpha8
235    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
236
237    texture->blend = true;
238    glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, texture->width, texture->height, 0,
239            GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.getPixels());
240
241    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
242    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
243
244    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
245    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
246}
247
248}; // namespace uirenderer
249}; // namespace android
250