GradientCache.cpp revision d61fd4ede537695d6f7c340aae365095e5bade4d 
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(Properties::gradientCacheSize)
69        , mUseFloatTexture(extensions.hasFloatTextures())
70        , mHasNpot(extensions.hasNPot()){
71    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
72
73    mCache.setOnEntryRemovedListener(this);
74}
75
76GradientCache::~GradientCache() {
77    mCache.clear();
78}
79
80///////////////////////////////////////////////////////////////////////////////
81// Size management
82///////////////////////////////////////////////////////////////////////////////
83
84uint32_t GradientCache::getSize() {
85    return mSize;
86}
87
88uint32_t GradientCache::getMaxSize() {
89    return mMaxSize;
90}
91
92///////////////////////////////////////////////////////////////////////////////
93// Callbacks
94///////////////////////////////////////////////////////////////////////////////
95
96void GradientCache::operator()(GradientCacheEntry&, Texture*& texture) {
97    if (texture) {
98        mSize -= texture->objectSize();
99        texture->deleteTexture();
100        delete texture;
101    }
102}
103
104///////////////////////////////////////////////////////////////////////////////
105// Caching
106///////////////////////////////////////////////////////////////////////////////
107
108Texture* GradientCache::get(uint32_t* colors, float* positions, int count) {
109    GradientCacheEntry gradient(colors, positions, count);
110    Texture* texture = mCache.get(gradient);
111
112    if (!texture) {
113        texture = addLinearGradient(gradient, colors, positions, count);
114    }
115
116    return texture;
117}
118
119void GradientCache::clear() {
120    mCache.clear();
121}
122
123void GradientCache::getGradientInfo(const uint32_t* colors, const int count,
124        GradientInfo& info) {
125    uint32_t width = 256 * (count - 1);
126
127    // If the npot extension is not supported we cannot use non-clamp
128    // wrap modes. We therefore find the nearest largest power of 2
129    // unless width is already a power of 2
130    if (!mHasNpot && (width & (width - 1)) != 0) {
131        width = 1 << (32 - __builtin_clz(width));
132    }
133
134    bool hasAlpha = false;
135    for (int i = 0; i < count; i++) {
136        if (((colors[i] >> 24) & 0xff) < 255) {
137            hasAlpha = true;
138            break;
139        }
140    }
141
142    info.width = min(width, uint32_t(mMaxTextureSize));
143    info.hasAlpha = hasAlpha;
144}
145
146Texture* GradientCache::addLinearGradient(GradientCacheEntry& gradient,
147        uint32_t* colors, float* positions, int count) {
148
149    GradientInfo info;
150    getGradientInfo(colors, count, info);
151
152    Texture* texture = new Texture(Caches::getInstance());
153    texture->blend = info.hasAlpha;
154    texture->generation = 1;
155
156    // Assume the cache is always big enough
157    const uint32_t size = info.width * 2 * bytesPerPixel();
158    while (getSize() + size > mMaxSize) {
159        LOG_ALWAYS_FATAL_IF(!mCache.removeOldest(),
160                "Ran out of things to remove from the cache? getSize() = %" PRIu32
161                ", size = %" PRIu32 ", mMaxSize = %" PRIu32 ", width = %" PRIu32,
162                getSize(), size, mMaxSize, info.width);
163    }
164
165    generateTexture(colors, positions, info.width, 2, texture);
166
167    mSize += size;
168    LOG_ALWAYS_FATAL_IF((int)size != texture->objectSize(),
169            "size != texture->objectSize(), size %" PRIu32 ", objectSize %d"
170            " width = %" PRIu32 " bytesPerPixel() = %zu",
171            size, texture->objectSize(), info.width, bytesPerPixel());
172    mCache.put(gradient, texture);
173
174    return texture;
175}
176
177size_t GradientCache::bytesPerPixel() const {
178    // We use 4 channels (RGBA)
179    return 4 * (mUseFloatTexture ? sizeof(float) : sizeof(uint8_t));
180}
181
182void GradientCache::splitToBytes(uint32_t inColor, GradientColor& outColor) const {
183    outColor.r = (inColor >> 16) & 0xff;
184    outColor.g = (inColor >>  8) & 0xff;
185    outColor.b = (inColor >>  0) & 0xff;
186    outColor.a = (inColor >> 24) & 0xff;
187}
188
189void GradientCache::splitToFloats(uint32_t inColor, GradientColor& outColor) const {
190    outColor.r = ((inColor >> 16) & 0xff) / 255.0f;
191    outColor.g = ((inColor >>  8) & 0xff) / 255.0f;
192    outColor.b = ((inColor >>  0) & 0xff) / 255.0f;
193    outColor.a = ((inColor >> 24) & 0xff) / 255.0f;
194}
195
196void GradientCache::mixBytes(GradientColor& start, GradientColor& end, float amount,
197        uint8_t*& dst) const {
198    float oppAmount = 1.0f - amount;
199    const float alpha = start.a * oppAmount + end.a * amount;
200    const float a = alpha / 255.0f;
201
202    *dst++ = uint8_t(a * (start.r * oppAmount + end.r * amount));
203    *dst++ = uint8_t(a * (start.g * oppAmount + end.g * amount));
204    *dst++ = uint8_t(a * (start.b * oppAmount + end.b * amount));
205    *dst++ = uint8_t(alpha);
206}
207
208void GradientCache::mixFloats(GradientColor& start, GradientColor& end, float amount,
209        uint8_t*& dst) const {
210    float oppAmount = 1.0f - amount;
211    const float a = start.a * oppAmount + end.a * amount;
212
213    float* d = (float*) dst;
214    *d++ = a * (start.r * oppAmount + end.r * amount);
215    *d++ = a * (start.g * oppAmount + end.g * amount);
216    *d++ = a * (start.b * oppAmount + end.b * amount);
217    *d++ = a;
218
219    dst += 4 * sizeof(float);
220}
221
222void GradientCache::generateTexture(uint32_t* colors, float* positions,
223        const uint32_t width, const uint32_t height, Texture* texture) {
224    const GLsizei rowBytes = width * bytesPerPixel();
225    uint8_t pixels[rowBytes * height];
226
227    static ChannelSplitter gSplitters[] = {
228            &android::uirenderer::GradientCache::splitToBytes,
229            &android::uirenderer::GradientCache::splitToFloats,
230    };
231    ChannelSplitter split = gSplitters[mUseFloatTexture];
232
233    static ChannelMixer gMixers[] = {
234            &android::uirenderer::GradientCache::mixBytes,
235            &android::uirenderer::GradientCache::mixFloats,
236    };
237    ChannelMixer mix = gMixers[mUseFloatTexture];
238
239    GradientColor start;
240    (this->*split)(colors[0], start);
241
242    GradientColor end;
243    (this->*split)(colors[1], end);
244
245    int currentPos = 1;
246    float startPos = positions[0];
247    float distance = positions[1] - startPos;
248
249    uint8_t* dst = pixels;
250    for (uint32_t x = 0; x < width; x++) {
251        float pos = x / float(width - 1);
252        if (pos > positions[currentPos]) {
253            start = end;
254            startPos = positions[currentPos];
255
256            currentPos++;
257
258            (this->*split)(colors[currentPos], end);
259            distance = positions[currentPos] - startPos;
260        }
261
262        float amount = (pos - startPos) / distance;
263        (this->*mix)(start, end, amount, dst);
264    }
265
266    memcpy(pixels + rowBytes, pixels, rowBytes);
267
268    if (mUseFloatTexture) {
269        // We have to use GL_RGBA16F because GL_RGBA32F does not support filtering
270        texture->upload(GL_RGBA16F, width, height, GL_RGBA, GL_FLOAT, pixels);
271    } else {
272        texture->upload(GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
273    }
274
275    texture->setFilter(GL_LINEAR);
276    texture->setWrap(GL_CLAMP_TO_EDGE);
277}
278
279}; // namespace uirenderer
280}; // namespace android
281