3 * Copyright 2012 Google Inc.
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
9 #include "GrTextureStripAtlas.h"
10 #include "SkPixelRef.h"
11 #include "SkTSearch.h"
12 #include "GrTexture.h"
15 #define VALIDATE this->validate()
20 class GrTextureStripAtlas::Hash : public SkTDynamicHash<GrTextureStripAtlas::AtlasEntry,
21 GrTextureStripAtlas::AtlasEntry::Key> {};
23 int32_t GrTextureStripAtlas::gCacheCount = 0;
25 GrTextureStripAtlas::Hash* GrTextureStripAtlas::gAtlasCache = NULL;
27 GrTextureStripAtlas::Hash* GrTextureStripAtlas::GetCache() {
29 if (NULL == gAtlasCache) {
30 gAtlasCache = SkNEW(Hash);
36 // Remove the specified atlas from the cache
37 void GrTextureStripAtlas::CleanUp(const GrContext*, void* info) {
40 AtlasEntry* entry = static_cast<AtlasEntry*>(info);
42 // remove the cache entry
43 GetCache()->remove(entry->fKey);
45 // remove the actual entry
48 if (0 == GetCache()->count()) {
49 SkDELETE(gAtlasCache);
54 GrTextureStripAtlas* GrTextureStripAtlas::GetAtlas(const GrTextureStripAtlas::Desc& desc) {
56 key.setKeyData(desc.asKey());
57 AtlasEntry* entry = GetCache()->find(key);
59 entry = SkNEW(AtlasEntry);
61 entry->fAtlas = SkNEW_ARGS(GrTextureStripAtlas, (desc));
64 desc.fContext->addCleanUp(CleanUp, entry);
66 GetCache()->add(entry);
72 GrTextureStripAtlas::GrTextureStripAtlas(GrTextureStripAtlas::Desc desc)
73 : fCacheKey(sk_atomic_inc(&gCacheCount))
76 , fNumRows(desc.fHeight / desc.fRowHeight)
78 , fRows(SkNEW_ARRAY(AtlasRow, fNumRows))
81 SkASSERT(fNumRows * fDesc.fRowHeight == fDesc.fHeight);
83 fNormalizedYHeight = SK_Scalar1 / fDesc.fHeight;
87 GrTextureStripAtlas::~GrTextureStripAtlas() {
88 SkDELETE_ARRAY(fRows);
91 int GrTextureStripAtlas::lockRow(const SkBitmap& data) {
93 if (0 == fLockedRows) {
97 int key = data.getGenerationID();
99 int index = this->searchByKey(key);
102 // We already have the data in a row, so we can just return that row
103 AtlasRow* row = fKeyTable[index];
104 if (0 == row->fLocks) {
105 this->removeFromLRU(row);
110 // Since all the rows are always stored in a contiguous array, we can save the memory
111 // required for storing row numbers and just compute it with some pointer arithmetic
112 rowNumber = static_cast<int>(row - fRows);
114 // ~index is the index where we will insert the new key to keep things sorted
117 // We don't have this data cached, so pick the least recently used row to copy into
118 AtlasRow* row = this->getLRU();
123 // force a flush, which should unlock all the rows; then try again
124 fDesc.fContext->flush();
125 row = this->getLRU();
132 this->removeFromLRU(row);
134 uint32_t oldKey = row->fKey;
136 // If we are writing into a row that already held bitmap data, we need to remove the
137 // reference to that genID which is stored in our sorted table of key values.
138 if (oldKey != kEmptyAtlasRowKey) {
140 // Find the entry in the list; if it's before the index where we plan on adding the new
141 // entry, we decrement since it will shift elements ahead of it back by one.
142 int oldIndex = this->searchByKey(oldKey);
143 if (oldIndex < index) {
147 fKeyTable.remove(oldIndex);
152 fKeyTable.insert(index, 1, &row);
153 rowNumber = static_cast<int>(row - fRows);
155 SkAutoLockPixels lock(data);
157 // Pass in the kDontFlush flag, since we know we're writing to a part of this texture
158 // that is not currently in use
159 fTexture->writePixels(0, rowNumber * fDesc.fRowHeight,
160 fDesc.fWidth, fDesc.fRowHeight,
161 SkImageInfo2GrPixelConfig(data.info()),
164 GrContext::kDontFlush_PixelOpsFlag);
167 SkASSERT(rowNumber >= 0);
172 void GrTextureStripAtlas::unlockRow(int row) {
176 SkASSERT(fRows[row].fLocks >= 0 && fLockedRows >= 0);
177 if (0 == fRows[row].fLocks) {
178 this->appendLRU(fRows + row);
180 if (0 == fLockedRows) {
181 this->unlockTexture();
186 GrTextureStripAtlas::AtlasRow* GrTextureStripAtlas::getLRU() {
187 // Front is least-recently-used
188 AtlasRow* row = fLRUFront;
192 void GrTextureStripAtlas::lockTexture() {
193 GrTextureParams params;
194 GrSurfaceDesc texDesc;
195 texDesc.fWidth = fDesc.fWidth;
196 texDesc.fHeight = fDesc.fHeight;
197 texDesc.fConfig = fDesc.fConfig;
199 static const GrCacheID::Domain gTextureStripAtlasDomain = GrCacheID::GenerateDomain();
201 *key.fData32 = fCacheKey;
202 memset(key.fData32 + 1, 0, sizeof(key) - sizeof(uint32_t));
203 GrCacheID cacheID(gTextureStripAtlasDomain, key);
205 fTexture = fDesc.fContext->findAndRefTexture(texDesc, cacheID, ¶ms);
206 if (NULL == fTexture) {
207 fTexture = fDesc.fContext->createTexture(¶ms, texDesc, cacheID, NULL, 0);
208 // This is a new texture, so all of our cache info is now invalid
215 void GrTextureStripAtlas::unlockTexture() {
216 SkASSERT(fTexture && 0 == fLockedRows);
221 void GrTextureStripAtlas::initLRU() {
224 // Initially all the rows are in the LRU list
225 for (int i = 0; i < fNumRows; ++i) {
226 fRows[i].fKey = kEmptyAtlasRowKey;
227 fRows[i].fNext = NULL;
228 fRows[i].fPrev = NULL;
229 this->appendLRU(fRows + i);
231 SkASSERT(NULL == fLRUFront || NULL == fLRUFront->fPrev);
232 SkASSERT(NULL == fLRUBack || NULL == fLRUBack->fNext);
235 void GrTextureStripAtlas::appendLRU(AtlasRow* row) {
236 SkASSERT(NULL == row->fPrev && NULL == row->fNext);
237 if (NULL == fLRUFront && NULL == fLRUBack) {
241 row->fPrev = fLRUBack;
242 fLRUBack->fNext = row;
247 void GrTextureStripAtlas::removeFromLRU(AtlasRow* row) {
249 if (row->fNext && row->fPrev) {
250 row->fPrev->fNext = row->fNext;
251 row->fNext->fPrev = row->fPrev;
253 if (NULL == row->fNext) {
254 SkASSERT(row == fLRUBack);
255 fLRUBack = row->fPrev;
257 fLRUBack->fNext = NULL;
260 if (NULL == row->fPrev) {
261 SkASSERT(row == fLRUFront);
262 fLRUFront = row->fNext;
264 fLRUFront->fPrev = NULL;
272 int GrTextureStripAtlas::searchByKey(uint32_t key) {
275 return SkTSearch<const AtlasRow,
276 GrTextureStripAtlas::KeyLess>((const AtlasRow**)fKeyTable.begin(),
283 void GrTextureStripAtlas::validate() {
285 // Our key table should be sorted
286 uint32_t prev = 1 > fKeyTable.count() ? 0 : fKeyTable[0]->fKey;
287 for (int i = 1; i < fKeyTable.count(); ++i) {
288 SkASSERT(prev < fKeyTable[i]->fKey);
289 SkASSERT(fKeyTable[i]->fKey != kEmptyAtlasRowKey);
290 prev = fKeyTable[i]->fKey;
294 // Validate LRU pointers, and count LRU entries
295 SkASSERT(NULL == fLRUFront || NULL == fLRUFront->fPrev);
296 SkASSERT(NULL == fLRUBack || NULL == fLRUBack->fNext);
297 for (AtlasRow* r = fLRUFront; r != NULL; r = r->fNext) {
298 if (NULL == r->fNext) {
299 SkASSERT(r == fLRUBack);
301 SkASSERT(r->fNext->fPrev == r);
309 for (int i = 0; i < fNumRows; ++i) {
310 rowLocks += fRows[i].fLocks;
311 if (0 == fRows[i].fLocks) {
314 // Step through the LRU and make sure it's present
315 for (AtlasRow* r = fLRUFront; r != NULL; r = r->fNext) {
316 if (r == &fRows[i]) {
323 // If we are locked, we should have a key
324 SkASSERT(kEmptyAtlasRowKey != fRows[i].fKey);
327 // If we have a key != kEmptyAtlasRowKey, it should be in the key table
328 SkASSERT(fRows[i].fKey == kEmptyAtlasRowKey || this->searchByKey(fRows[i].fKey) >= 0);
331 // Our count of locks should equal the sum of row locks, unless we ran out of rows and flushed,
332 // in which case we'll have one more lock than recorded in the rows (to represent the pending
333 // lock of a row; which ensures we don't unlock the texture prematurely).
334 SkASSERT(rowLocks == fLockedRows || rowLocks + 1 == fLockedRows);
336 // We should have one lru entry for each free row
337 SkASSERT(freeRows == lruCount);
339 // If we have locked rows, we should have a locked texture, otherwise
340 // it should be unlocked
341 if (fLockedRows == 0) {
342 SkASSERT(NULL == fTexture);