Home | History | Annotate | Download | only in hwui 
      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 #ifndef ANDROID_HWUI_LAYER_CACHE_H
     18 #define ANDROID_HWUI_LAYER_CACHE_H
     19 
     20 #include "Debug.h"
     21 #include "Layer.h"
     22 #include "Properties.h"
     23 #include "utils/SortedList.h"
     24 
     25 namespace android {
     26 namespace uirenderer {
     27 
     28 ///////////////////////////////////////////////////////////////////////////////
     29 // Defines
     30 ///////////////////////////////////////////////////////////////////////////////
     31 
     32 // Debug
     33 #if DEBUG_LAYERS
     34     #define LAYER_LOGD(...) LOGD(__VA_ARGS__)
     35 #else
     36     #define LAYER_LOGD(...)
     37 #endif
     38 
     39 ///////////////////////////////////////////////////////////////////////////////
     40 // Cache
     41 ///////////////////////////////////////////////////////////////////////////////
     42 
     43 class LayerCache {
     44 public:
     45     LayerCache();
     46     ~LayerCache();
     47 
     48     /**
     49      * Returns a layer large enough for the specified dimensions. If no suitable
     50      * layer can be found, a new one is created and returned. If creating a new
     51      * layer fails, NULL is returned.
     52      *
     53      * When a layer is obtained from the cache, it is removed and the total
     54      * size of the cache goes down.
     55      *
     56      * @param width The desired width of the layer
     57      * @param width The desired height of the layer
     58      */
     59     Layer* get(const uint32_t width, const uint32_t height);
     60 
     61     /**
     62      * Adds the layer to the cache. The layer will not be added if there is
     63      * not enough space available. Adding a layer can cause other layers to
     64      * be removed from the cache.
     65      *
     66      * @param layer The layer to add to the cache
     67      *
     68      * @return True if the layer was added, false otherwise.
     69      */
     70     bool put(Layer* layer);
     71     /**
     72      * Clears the cache. This causes all layers to be deleted.
     73      */
     74     void clear();
     75     /**
     76      * Resize the specified layer if needed.
     77      *
     78      * @param layer The layer to resize
     79      * @param width The new width of the layer
     80      * @param height The new height of the layer
     81      *
     82      * @return True if the layer was resized or nothing happened, false if
     83      *         a failure occurred during the resizing operation
     84      */
     85     bool resize(Layer* layer, const uint32_t width, const uint32_t height);
     86 
     87     /**
     88      * Sets the maximum size of the cache in bytes.
     89      */
     90     void setMaxSize(uint32_t maxSize);
     91     /**
     92      * Returns the maximum size of the cache in bytes.
     93      */
     94     uint32_t getMaxSize();
     95     /**
     96      * Returns the current size of the cache in bytes.
     97      */
     98     uint32_t getSize();
     99 
    100     /**
    101      * Prints out the content of the cache.
    102      */
    103     void dump();
    104 
    105 private:
    106     void deleteLayer(Layer* layer);
    107 
    108     struct LayerEntry {
    109         LayerEntry():
    110             mLayer(NULL), mWidth(0), mHeight(0) {
    111         }
    112 
    113         LayerEntry(const uint32_t layerWidth, const uint32_t layerHeight): mLayer(NULL) {
    114             mWidth = uint32_t(ceilf(layerWidth / float(LAYER_SIZE)) * LAYER_SIZE);
    115             mHeight = uint32_t(ceilf(layerHeight / float(LAYER_SIZE)) * LAYER_SIZE);
    116         }
    117 
    118         LayerEntry(Layer* layer):
    119             mLayer(layer), mWidth(layer->getWidth()), mHeight(layer->getHeight()) {
    120         }
    121 
    122         bool operator<(const LayerEntry& rhs) const {
    123             if (mWidth == rhs.mWidth) {
    124                 return mHeight < rhs.mHeight;
    125             }
    126             return mWidth < rhs.mWidth;
    127         }
    128 
    129         bool operator==(const LayerEntry& rhs) const {
    130             return mWidth == rhs.mWidth && mHeight == rhs.mHeight;
    131         }
    132 
    133         Layer* mLayer;
    134         uint32_t mWidth;
    135         uint32_t mHeight;
    136     }; // struct LayerEntry
    137 
    138     SortedList<LayerEntry> mCache;
    139 
    140     uint32_t mSize;
    141     uint32_t mMaxSize;
    142 }; // class LayerCache
    143 
    144 }; // namespace uirenderer
    145 }; // namespace android
    146 
    147 #endif // ANDROID_HWUI_LAYER_CACHE_H
    148