libs/hwui/GradientCache.cpp

   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
  26 namespace android {
  27 namespace uirenderer {
  28
  29 ///////////////////////////////////////////////////////////////////////////////
  30 // Functions
  31 ///////////////////////////////////////////////////////////////////////////////
  32
  33 template<typename T>
  34 static inline T min(T a, T b) {
  35     return a < b ? a : b;
  36 }
  37
  38 ///////////////////////////////////////////////////////////////////////////////
  39 // Cache entry
  40 ///////////////////////////////////////////////////////////////////////////////
  41
  42 hash_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
  51 int 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
  65 GradientCache::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
  76 GradientCache::~GradientCache() {
  77     mCache.clear();
  78 }
  79
  80 ///////////////////////////////////////////////////////////////////////////////
  81 // Size management
  82 ///////////////////////////////////////////////////////////////////////////////
  83
  84 uint32_t GradientCache::getSize() {
  85     return mSize;
  86 }
  87
  88 uint32_t GradientCache::getMaxSize() {
  89     return mMaxSize;
  90 }
  91
  92 ///////////////////////////////////////////////////////////////////////////////
  93 // Callbacks
  94 ///////////////////////////////////////////////////////////////////////////////
  95
  96 void 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
 108 Texture* 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
 119 void GradientCache::clear() {
 120     mCache.clear();
 121 }
 122
 123 void 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
 146 Texture* 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
 177 size_t GradientCache::bytesPerPixel() const {
 178     // We use 4 channels (RGBA)
 179     return 4 * (mUseFloatTexture ? sizeof(float) : sizeof(uint8_t));
 180 }
 181
 182 void 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
 189 void 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
 196 void 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
 208 void 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
 222 void 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