The Tor Browser: comparison gfx/skia/trunk/src/gpu/effects/GrTextureStripAtlas.h

--1:000000000000
+:8d293b5fd006
+/*
+* 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

The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/gpu/effects/GrTextureStripAtlas.h

gfx/skia/trunk/src/gpu/effects/GrTextureStripAtlas.h