GradientCache.cpp revision 83c9b5bf638d75a3395f57c2c57c31c959632f9d 
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#include <utils/JenkinsHash.h>
18
19#include "Caches.h"
20#include "Debug.h"
21#include "GradientCache.h"
22#include "Properties.h"
23
24#include <cutils/properties.h>
25
26namespace android {
27namespace uirenderer {
28
29///////////////////////////////////////////////////////////////////////////////
30// Functions
31///////////////////////////////////////////////////////////////////////////////
32
33template<typename T>
34static inline T min(T a, T b) {
35    return a < b ? a : b;
36}
37
38///////////////////////////////////////////////////////////////////////////////
39// Cache entry
40///////////////////////////////////////////////////////////////////////////////
41
42hash_t GradientCacheEntry::hash() const {
43    uint32_t hash = JenkinsHashMix(0, count);
44    for (uint32_t i = 0; i < count; i++) {
45        hash = JenkinsHashMix(hash, android::hash_type(colors[i]));
46        hash = JenkinsHashMix(hash, android::hash_type(positions[i]));
47    }
48    return JenkinsHashWhiten(hash);
49}
50
51int GradientCacheEntry::compare(const GradientCacheEntry& lhs, const GradientCacheEntry& rhs) {
52    int deltaInt = int(lhs.count) - int(rhs.count);
53    if (deltaInt != 0) return deltaInt;
54
55    deltaInt = memcmp(lhs.colors.get(), rhs.colors.get(), lhs.count * sizeof(uint32_t));
56    if (deltaInt != 0) return deltaInt;
57
58    return memcmp(lhs.positions.get(), rhs.positions.get(), lhs.count * sizeof(float));
59}
60
61///////////////////////////////////////////////////////////////////////////////
62// Constructors/destructor
63///////////////////////////////////////////////////////////////////////////////
64
65GradientCache::GradientCache(Extensions& extensions)
66        : mCache(LruCache<GradientCacheEntry, Texture*>::kUnlimitedCapacity)
67        , mSize(0)
68        , mMaxSize(MB(DEFAULT_GRADIENT_CACHE_SIZE))
69        , mUseFloatTexture(extensions.hasFloatTextures())
70        , mHasNpot(extensions.hasNPot()){
71    char property[PROPERTY_VALUE_MAX];
72    if (property_get(PROPERTY_GRADIENT_CACHE_SIZE, property, nullptr) > 0) {
73        INIT_LOGD("  Setting gradient cache size to %sMB", property);
74        setMaxSize(MB(atof(property)));
75    } else {
76        INIT_LOGD("  Using default gradient cache size of %.2fMB", DEFAULT_GRADIENT_CACHE_SIZE);
77    }
78
79    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
80
81    mCache.setOnEntryRemovedListener(this);
82}
83
84GradientCache::~GradientCache() {
85    mCache.clear();
86}
87
88///////////////////////////////////////////////////////////////////////////////
89// Size management
90///////////////////////////////////////////////////////////////////////////////
91
92uint32_t GradientCache::getSize() {
93    return mSize;
94}
95
96uint32_t GradientCache::getMaxSize() {
97    return mMaxSize;
98}
99
100void GradientCache::setMaxSize(uint32_t maxSize) {
101    mMaxSize = maxSize;
102    while (mSize > mMaxSize) {
103        mCache.removeOldest();
104    }
105}
106
107///////////////////////////////////////////////////////////////////////////////
108// Callbacks
109///////////////////////////////////////////////////////////////////////////////
110
111void GradientCache::operator()(GradientCacheEntry&, Texture*& texture) {
112    if (texture) {
113        mSize -= texture->objectSize();
114        texture->deleteTexture();
115        delete texture;
116    }
117}
118
119///////////////////////////////////////////////////////////////////////////////
120// Caching
121///////////////////////////////////////////////////////////////////////////////
122
123Texture* GradientCache::get(uint32_t* colors, float* positions, int count) {
124    GradientCacheEntry gradient(colors, positions, count);
125    Texture* texture = mCache.get(gradient);
126
127    if (!texture) {
128        texture = addLinearGradient(gradient, colors, positions, count);
129    }
130
131    return texture;
132}
133
134void GradientCache::clear() {
135    mCache.clear();
136}
137
138void GradientCache::getGradientInfo(const uint32_t* colors, const int count,
139        GradientInfo& info) {
140    uint32_t width = 256 * (count - 1);
141
142    // If the npot extension is not supported we cannot use non-clamp
143    // wrap modes. We therefore find the nearest largest power of 2
144    // unless width is already a power of 2
145    if (!mHasNpot && (width & (width - 1)) != 0) {
146        width = 1 << (32 - __builtin_clz(width));
147    }
148
149    bool hasAlpha = false;
150    for (int i = 0; i < count; i++) {
151        if (((colors[i] >> 24) & 0xff) < 255) {
152            hasAlpha = true;
153            break;
154        }
155    }
156
157    info.width = min(width, uint32_t(mMaxTextureSize));
158    info.hasAlpha = hasAlpha;
159}
160
161Texture* GradientCache::addLinearGradient(GradientCacheEntry& gradient,
162        uint32_t* colors, float* positions, int count) {
163
164    GradientInfo info;
165    getGradientInfo(colors, count, info);
166
167    Texture* texture = new Texture(Caches::getInstance());
168    texture->blend = info.hasAlpha;
169    texture->generation = 1;
170
171    // Assume the cache is always big enough
172    const uint32_t size = info.width * 2 * bytesPerPixel();
173    while (getSize() + size > mMaxSize) {
174        LOG_ALWAYS_FATAL_IF(!mCache.removeOldest(),
175                "Ran out of things to remove from the cache? getSize() = %" PRIu32
176                ", size = %" PRIu32 ", mMaxSize = %" PRIu32 ", width = %" PRIu32,
177                getSize(), size, mMaxSize, info.width);
178    }
179
180    generateTexture(colors, positions, info.width, 2, texture);
181
182    mSize += size;
183    mCache.put(gradient, texture);
184
185    return texture;
186}
187
188size_t GradientCache::bytesPerPixel() const {
189    // We use 4 channels (RGBA)
190    return 4 * (mUseFloatTexture ? sizeof(float) : sizeof(uint8_t));
191}
192
193void GradientCache::splitToBytes(uint32_t inColor, GradientColor& outColor) const {
194    outColor.r = (inColor >> 16) & 0xff;
195    outColor.g = (inColor >>  8) & 0xff;
196    outColor.b = (inColor >>  0) & 0xff;
197    outColor.a = (inColor >> 24) & 0xff;
198}
199
200void GradientCache::splitToFloats(uint32_t inColor, GradientColor& outColor) const {
201    outColor.r = ((inColor >> 16) & 0xff) / 255.0f;
202    outColor.g = ((inColor >>  8) & 0xff) / 255.0f;
203    outColor.b = ((inColor >>  0) & 0xff) / 255.0f;
204    outColor.a = ((inColor >> 24) & 0xff) / 255.0f;
205}
206
207void GradientCache::mixBytes(GradientColor& start, GradientColor& end, float amount,
208        uint8_t*& dst) const {
209    float oppAmount = 1.0f - amount;
210    const float alpha = start.a * oppAmount + end.a * amount;
211    const float a = alpha / 255.0f;
212
213    *dst++ = uint8_t(a * (start.r * oppAmount + end.r * amount));
214    *dst++ = uint8_t(a * (start.g * oppAmount + end.g * amount));
215    *dst++ = uint8_t(a * (start.b * oppAmount + end.b * amount));
216    *dst++ = uint8_t(alpha);
217}
218
219void GradientCache::mixFloats(GradientColor& start, GradientColor& end, float amount,
220        uint8_t*& dst) const {
221    float oppAmount = 1.0f - amount;
222    const float a = start.a * oppAmount + end.a * amount;
223
224    float* d = (float*) dst;
225    *d++ = a * (start.r * oppAmount + end.r * amount);
226    *d++ = a * (start.g * oppAmount + end.g * amount);
227    *d++ = a * (start.b * oppAmount + end.b * amount);
228    *d++ = a;
229
230    dst += 4 * sizeof(float);
231}
232
233void GradientCache::generateTexture(uint32_t* colors, float* positions,
234        const uint32_t width, const uint32_t height, Texture* texture) {
235    const GLsizei rowBytes = width * bytesPerPixel();
236    uint8_t pixels[rowBytes * height];
237
238    static ChannelSplitter gSplitters[] = {
239            &android::uirenderer::GradientCache::splitToBytes,
240            &android::uirenderer::GradientCache::splitToFloats,
241    };
242    ChannelSplitter split = gSplitters[mUseFloatTexture];
243
244    static ChannelMixer gMixers[] = {
245            &android::uirenderer::GradientCache::mixBytes,
246            &android::uirenderer::GradientCache::mixFloats,
247    };
248    ChannelMixer mix = gMixers[mUseFloatTexture];
249
250    GradientColor start;
251    (this->*split)(colors[0], start);
252
253    GradientColor end;
254    (this->*split)(colors[1], end);
255
256    int currentPos = 1;
257    float startPos = positions[0];
258    float distance = positions[1] - startPos;
259
260    uint8_t* dst = pixels;
261    for (uint32_t x = 0; x < width; x++) {
262        float pos = x / float(width - 1);
263        if (pos > positions[currentPos]) {
264            start = end;
265            startPos = positions[currentPos];
266
267            currentPos++;
268
269            (this->*split)(colors[currentPos], end);
270            distance = positions[currentPos] - startPos;
271        }
272
273        float amount = (pos - startPos) / distance;
274        (this->*mix)(start, end, amount, dst);
275    }
276
277    memcpy(pixels + rowBytes, pixels, rowBytes);
278
279    if (mUseFloatTexture) {
280        // We have to use GL_RGBA16F because GL_RGBA32F does not support filtering
281        texture->upload(GL_RGBA16F, width, height, GL_RGBA, GL_FLOAT, pixels);
282    } else {
283        texture->upload(GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
284    }
285
286    texture->setFilter(GL_LINEAR);
287    texture->setWrap(GL_CLAMP_TO_EDGE);
288}
289
290}; // namespace uirenderer
291}; // namespace android
292