The Tor Browser / file revision

 /*

  * Copyright 2012 Google Inc.

  *

  * Use of this source code is governed by a BSD-style license that can be

  * found in the LICENSE file.

  */

 #ifndef GrTextureStripAtlas_DEFINED

 #define GrTextureStripAtlas_DEFINED

 #include "GrBinHashKey.h"

 #include "GrTHashTable.h"

 #include "SkBitmap.h"

 #include "SkGr.h"

 #include "SkTDArray.h"

 #include "SkTypes.h"

 /**

  * Maintains a single large texture whose rows store many textures of a small fixed height,

  * stored in rows across the x-axis such that we can safely wrap/repeat them horizontally.

  */

 class GrTextureStripAtlas {

 public:

     /**

      * Descriptor struct which we'll use as a hash table key

      **/

     struct Desc {

         Desc() { memset(this, 0, sizeof(*this)); }

         uint16_t fWidth, fHeight, fRowHeight;

         GrPixelConfig fConfig;

         GrContext* fContext;

         const uint32_t* asKey() const { return reinterpret_cast<const uint32_t*>(this); }

     };

     /**

      * Try to find an atlas with the required parameters, creates a new one if necessary

      */

     static GrTextureStripAtlas* GetAtlas(const Desc& desc);

     ~GrTextureStripAtlas();

     /**

      * Add a texture to the atlas

      *  @param data Bitmap data to copy into the row

      *  @return The row index we inserted into, or -1 if we failed to find an open row. The caller

      *      is responsible for calling unlockRow() with this row index when it's done with it.

      */

     int lockRow(const SkBitmap& data);

     void unlockRow(int row);

     /**

      * These functions help turn an integer row index in [0, 1, 2, ... numRows] into a scalar y

      * texture coordinate in [0, 1] that we can use in a shader.

      *

      * If a regular texture access without using the atlas looks like:

      *

      *      texture2D(sampler, vec2(x, y))

      *

      * Then when using the atlas we'd replace it with:

      *

      *       texture2D(sampler, vec2(x, yOffset + y * scaleFactor))

      *

      * Where yOffset, returned by getYOffset(), is the offset to the start of the row within the

      * atlas and scaleFactor, returned by getVerticalScaleFactor(), is the y-scale of the row,

      * relative to the height of the overall atlas texture.

      */

     SkScalar getYOffset(int row) const { return SkIntToScalar(row) / fNumRows; }

     SkScalar getVerticalScaleFactor() const { return SkIntToScalar(fDesc.fRowHeight) / fDesc.fHeight; }

     GrContext* getContext() const { return fDesc.fContext; }

     GrTexture* getTexture() const { return fTexture; }

 private:

     // Key to indicate an atlas row without any meaningful data stored in it

     const static uint32_t kEmptyAtlasRowKey = 0xffffffff;

     /**

      * The state of a single row in our cache, next/prev pointers allow these to be chained

      * together to represent LRU status

      */

     struct AtlasRow : public SkNoncopyable {

         AtlasRow() : fKey(kEmptyAtlasRowKey), fLocks(0), fNext(NULL), fPrev(NULL) { }

         // GenerationID of the bitmap that is represented by this row, 0xffffffff means "empty"

         uint32_t fKey;

         // How many times this has been locked (0 == unlocked)

         int32_t fLocks;

         // We maintain an LRU linked list between unlocked nodes with these pointers

         AtlasRow* fNext;

         AtlasRow* fPrev;

     };

     /**

      * We'll only allow construction via the static GrTextureStripAtlas::GetAtlas

      */

     GrTextureStripAtlas(Desc desc);

     void lockTexture();

     void unlockTexture();

     /**

      * Initialize our LRU list (if one already exists, clear it and start anew)

      */

     void initLRU();

     /**

      * Grabs the least recently used free row out of the LRU list, returns NULL if no rows are free.

      */

     AtlasRow* getLRU();

     void appendLRU(AtlasRow* row);

     void removeFromLRU(AtlasRow* row);

     /**

      * Searches the key table for a key and returns the index if found; if not found, it returns

      * the bitwise not of the index at which we could insert the key to maintain a sorted list.

      **/

     int searchByKey(uint32_t key);

     /**

      * Compare two atlas rows by key, so we can sort/search by key

      */

     static bool KeyLess(const AtlasRow& lhs, const AtlasRow& rhs) {

         return lhs.fKey < rhs.fKey;

     }

 #ifdef SK_DEBUG

     void validate();

 #endif

     /**

      * Clean up callback registered with GrContext. Allows this class to

      * free up any allocated AtlasEntry and GrTextureStripAtlas objects

      */

     static void CleanUp(const GrContext* context, void* info);

     // Hash table entry for atlases

     class AtlasEntry;

     class AtlasHashKey : public GrBinHashKey<sizeof(GrTextureStripAtlas::Desc)> {

     public:

         static bool Equals(const AtlasEntry& entry, const AtlasHashKey& key);

         static bool LessThan(const AtlasEntry& entry, const AtlasHashKey& key);

     };

     class AtlasEntry : public ::SkNoncopyable {

     public:

         AtlasEntry() : fAtlas(NULL) {}

         ~AtlasEntry() { SkDELETE(fAtlas); }

         AtlasHashKey fKey;

         GrTextureStripAtlas* fAtlas;

     };

     static GrTHashTable<AtlasEntry, AtlasHashKey, 8>* gAtlasCache;

     static GrTHashTable<AtlasEntry, AtlasHashKey, 8>* GetCache();

     // We increment gCacheCount for each atlas

     static int32_t gCacheCount;

     // A unique ID for this texture (formed with: gCacheCount++), so we can be sure that if we

     // get a texture back from the texture cache, that it's the same one we last used.

     const int32_t fCacheKey;

     // Total locks on all rows (when this reaches zero, we can unlock our texture)

     int32_t fLockedRows;

     const Desc fDesc;

     const uint16_t fNumRows;

     GrTexture* fTexture;

     // Array of AtlasRows which store the state of all our rows. Stored in a contiguous array, in

     // order that they appear in our texture, this means we can subtract this pointer from a row

     // pointer to get its index in the texture, and can save storing a row number in AtlasRow.

     AtlasRow* fRows;

     // Head and tail for linked list of least-recently-used rows (front = least recently used).

     // Note that when a texture is locked, it gets removed from this list until it is unlocked.

     AtlasRow* fLRUFront;

     AtlasRow* fLRUBack;

     // A list of pointers to AtlasRows that currently contain cached images, sorted by key

     SkTDArray<AtlasRow*> fKeyTable;

 };

 inline bool GrTextureStripAtlas::AtlasHashKey::Equals(const AtlasEntry& entry,

                                                       const AtlasHashKey& key) {

     return entry.fKey == key;

 }

 inline bool GrTextureStripAtlas::AtlasHashKey::LessThan(const AtlasEntry& entry,

                                                         const AtlasHashKey& key) {

     return entry.fKey < key;

 }

 #endif