libs/hwui/PathCache.h

   1 /*
   2  * Copyright (C) 2013 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 #ifndef ANDROID_HWUI_PATH_CACHE_H
  18 #define ANDROID_HWUI_PATH_CACHE_H
  19
  20 #include "Debug.h"
  21 #include "Texture.h"
  22 #include "hwui/Bitmap.h"
  23 #include "thread/Task.h"
  24 #include "thread/TaskProcessor.h"
  25 #include "utils/Macros.h"
  26 #include "utils/Pair.h"
  27
  28 #include <GLES2/gl2.h>
  29 #include <SkPaint.h>
  30 #include <SkPath.h>
  31 #include <utils/LruCache.h>
  32 #include <utils/Mutex.h>
  33
  34 #include <vector>
  35
  36 class SkCanvas;
  37 class SkPaint;
  38 struct SkRect;
  39
  40 namespace android {
  41 namespace uirenderer {
  42
  43 class Caches;
  44 ///////////////////////////////////////////////////////////////////////////////
  45 // Defines
  46 ///////////////////////////////////////////////////////////////////////////////
  47
  48 // Debug
  49 #if DEBUG_PATHS
  50     #define PATH_LOGD(...) ALOGD(__VA_ARGS__)
  51 #else
  52     #define PATH_LOGD(...)
  53 #endif
  54
  55 ///////////////////////////////////////////////////////////////////////////////
  56 // Classes
  57 ///////////////////////////////////////////////////////////////////////////////
  58
  59 struct PathTexture;
  60 class PathTask: public Task<sk_sp<Bitmap>> {
  61 public:
  62     PathTask(const SkPath* path, const SkPaint* paint, PathTexture* texture):
  63         path(*path), paint(*paint), texture(texture) {
  64     }
  65
  66     // copied, since input path not guaranteed to survive for duration of task
  67     const SkPath path;
  68
  69     // copied, since input paint may not be immutable
  70     const SkPaint paint;
  71     PathTexture* texture;
  72 };
  73
  74 /**
  75  * Alpha texture used to represent a path.
  76  */
  77 struct PathTexture: public Texture {
  78     PathTexture(Caches& caches, int generation)
  79         : Texture(caches) {
  80         this->generation = generation;
  81     }
  82
  83     ~PathTexture() {
  84         clearTask();
  85     }
  86
  87     /**
  88      * Left coordinate of the path bounds.
  89      */
  90     float left = 0;
  91     /**
  92      * Top coordinate of the path bounds.
  93      */
  94     float top = 0;
  95     /**
  96      * Offset to draw the path at the correct origin.
  97      */
  98     float offset = 0;
  99
 100     sp<PathTask> task() const {
 101         return mTask;
 102     }
 103
 104     void setTask(const sp<PathTask>& task) {
 105         mTask = task;
 106     }
 107
 108     void clearTask() {
 109         if (mTask != nullptr) {
 110             mTask.clear();
 111         }
 112     }
 113
 114 private:
 115     sp<PathTask> mTask;
 116 }; // struct PathTexture
 117
 118 enum class ShapeType {
 119     None,
 120     Rect,
 121     RoundRect,
 122     Circle,
 123     Oval,
 124     Arc,
 125     Path
 126 };
 127
 128 struct PathDescription {
 129     HASHABLE_TYPE(PathDescription);
 130     ShapeType type;
 131     SkPaint::Join join;
 132     SkPaint::Cap cap;
 133     SkPaint::Style style;
 134     float miter;
 135     float strokeWidth;
 136     SkPathEffect* pathEffect;
 137     union Shape {
 138         struct Path {
 139             uint32_t mGenerationID;
 140         } path;
 141         struct RoundRect {
 142             float mWidth;
 143             float mHeight;
 144             float mRx;
 145             float mRy;
 146         } roundRect;
 147         struct Circle {
 148             float mRadius;
 149         } circle;
 150         struct Oval {
 151             float mWidth;
 152             float mHeight;
 153         } oval;
 154         struct Rect {
 155             float mWidth;
 156             float mHeight;
 157         } rect;
 158         struct Arc {
 159             float mWidth;
 160             float mHeight;
 161             float mStartAngle;
 162             float mSweepAngle;
 163             bool mUseCenter;
 164         } arc;
 165     } shape;
 166
 167     PathDescription();
 168     PathDescription(ShapeType shapeType, const SkPaint* paint);
 169 };
 170
 171 /**
 172  * A simple LRU shape cache. The cache has a maximum size expressed in bytes.
 173  * Any texture added to the cache causing the cache to grow beyond the maximum
 174  * allowed size will also cause the oldest texture to be kicked out.
 175  */
 176 class PathCache: public OnEntryRemoved<PathDescription, PathTexture*> {
 177 public:
 178     PathCache();
 179     ~PathCache();
 180
 181     /**
 182      * Used as a callback when an entry is removed from the cache.
 183      * Do not invoke directly.
 184      */
 185     void operator()(PathDescription& path, PathTexture*& texture) override;
 186
 187     /**
 188      * Clears the cache. This causes all textures to be deleted.
 189      */
 190     void clear();
 191
 192     /**
 193      * Returns the maximum size of the cache in bytes.
 194      */
 195     uint32_t getMaxSize();
 196     /**
 197      * Returns the current size of the cache in bytes.
 198      */
 199     uint32_t getSize();
 200
 201     PathTexture* getRoundRect(float width, float height, float rx, float ry, const SkPaint* paint);
 202     PathTexture* getCircle(float radius, const SkPaint* paint);
 203     PathTexture* getOval(float width, float height, const SkPaint* paint);
 204     PathTexture* getRect(float width, float height, const SkPaint* paint);
 205     PathTexture* getArc(float width, float height, float startAngle, float sweepAngle,
 206             bool useCenter, const SkPaint* paint);
 207     PathTexture* get(const SkPath* path, const SkPaint* paint);
 208     void         remove(const SkPath* path, const SkPaint* paint);
 209
 210     /**
 211      * Removes the specified path. This is meant to be called from threads
 212      * that are not the EGL context thread.
 213      */
 214     ANDROID_API void removeDeferred(const SkPath* path);
 215     /**
 216      * Process deferred removals.
 217      */
 218     void clearGarbage();
 219     /**
 220      * Trims the contents of the cache, removing items until it's under its
 221      * specified limit.
 222      *
 223      * Trimming is used for caches that support pre-caching from a worker
 224      * thread. During pre-caching the maximum limit of the cache can be
 225      * exceeded for the duration of the frame. It is therefore required to
 226      * trim the cache at the end of the frame to keep the total amount of
 227      * memory used under control.
 228      */
 229     void trim();
 230
 231     /**
 232      * Precaches the specified path using background threads.
 233      */
 234     void precache(const SkPath* path, const SkPaint* paint);
 235
 236 private:
 237     PathTexture* addTexture(const PathDescription& entry,
 238             const SkPath *path, const SkPaint* paint);
 239
 240     /**
 241      * Generates the texture from a bitmap into the specified texture structure.
 242      */
 243     void generateTexture(Bitmap& bitmap, Texture* texture);
 244     void generateTexture(const PathDescription& entry, Bitmap& bitmap, PathTexture* texture,
 245             bool addToCache = true);
 246
 247     PathTexture* get(const PathDescription& entry) {
 248         return mCache.get(entry);
 249     }
 250
 251     /**
 252      * Ensures there is enough space in the cache for a texture of the specified
 253      * dimensions.
 254      */
 255     void purgeCache(uint32_t width, uint32_t height);
 256
 257     void removeTexture(PathTexture* texture);
 258
 259     void init();
 260
 261
 262     class PathProcessor: public TaskProcessor<sk_sp<Bitmap> > {
 263     public:
 264         explicit PathProcessor(Caches& caches);
 265         ~PathProcessor() { }
 266
 267         virtual void onProcess(const sp<Task<sk_sp<Bitmap> > >& task) override;
 268
 269     private:
 270         uint32_t mMaxTextureSize;
 271     };
 272
 273     LruCache<PathDescription, PathTexture*> mCache;
 274     uint32_t mSize;
 275     const uint32_t mMaxSize;
 276     GLuint mMaxTextureSize;
 277
 278     bool mDebugEnabled;
 279
 280     sp<PathProcessor> mProcessor;
 281
 282     std::vector<uint32_t> mGarbage;
 283     mutable Mutex mLock;
 284 }; // class PathCache
 285
 286 }; // namespace uirenderer
 287 }; // namespace android
 288
 289 #endif // ANDROID_HWUI_PATH_CACHE_H