am 5ab86ba0: am 89a63f02: am 0c31d97a: Merge "Switch TextureCache to SkPixelRef::fStableId" into lmp-mr1-dev
* commit '5ab86ba05decf12e8ee3f693aab6b265905049c6':
Switch TextureCache to SkPixelRef::fStableId
diff --git a/libs/hwui/ResourceCache.cpp b/libs/hwui/ResourceCache.cpp
index 12d4928..717ce9a 100644
--- a/libs/hwui/ResourceCache.cpp
+++ b/libs/hwui/ResourceCache.cpp
@@ -185,10 +185,9 @@
if (ref == NULL) {
// If we're not tracking this resource, just delete it
if (Caches::hasInstance()) {
- Caches::getInstance().textureCache.removeDeferred(resource);
- } else {
- delete resource;
+ Caches::getInstance().textureCache.releaseTexture(resource);
}
+ delete resource;
return;
}
ref->destroyed = true;
@@ -238,6 +237,9 @@
bool ResourceCache::recycleLocked(SkBitmap* resource) {
ssize_t index = mCache->indexOfKey(resource);
if (index < 0) {
+ if (Caches::hasInstance()) {
+ Caches::getInstance().textureCache.releaseTexture(resource);
+ }
// not tracking this resource; just recycle the pixel data
resource->setPixels(NULL, NULL);
return true;
@@ -262,17 +264,20 @@
*/
void ResourceCache::deleteResourceReferenceLocked(const void* resource, ResourceReference* ref) {
if (ref->recycled && ref->resourceType == kBitmap) {
- ((SkBitmap*) resource)->setPixels(NULL, NULL);
+ SkBitmap* bitmap = (SkBitmap*) resource;
+ if (Caches::hasInstance()) {
+ Caches::getInstance().textureCache.releaseTexture(bitmap);
+ }
+ bitmap->setPixels(NULL, NULL);
}
if (ref->destroyed) {
switch (ref->resourceType) {
case kBitmap: {
SkBitmap* bitmap = (SkBitmap*) resource;
if (Caches::hasInstance()) {
- Caches::getInstance().textureCache.removeDeferred(bitmap);
- } else {
- delete bitmap;
+ Caches::getInstance().textureCache.releaseTexture(bitmap);
}
+ delete bitmap;
}
break;
case kPath: {
diff --git a/libs/hwui/ResourceCache.h b/libs/hwui/ResourceCache.h
index c6cd7bf..a252f6c 100644
--- a/libs/hwui/ResourceCache.h
+++ b/libs/hwui/ResourceCache.h
@@ -44,7 +44,6 @@
class ResourceReference {
public:
- ResourceReference() { refCount = 0; recycled = false; destroyed = false;}
ResourceReference(ResourceType type) {
refCount = 0; recycled = false; destroyed = false; resourceType = type;
}
diff --git a/libs/hwui/TextureCache.cpp b/libs/hwui/TextureCache.cpp
index b1fa383..3677fac 100644
--- a/libs/hwui/TextureCache.cpp
+++ b/libs/hwui/TextureCache.cpp
@@ -20,6 +20,7 @@
#include <GLES2/gl2.h>
#include <SkCanvas.h>
+#include <SkPixelRef.h>
#include <utils/Mutex.h>
@@ -37,7 +38,7 @@
///////////////////////////////////////////////////////////////////////////////
TextureCache::TextureCache():
- mCache(LruCache<const SkPixelRef*, Texture*>::kUnlimitedCapacity),
+ mCache(LruCache<uint32_t, Texture*>::kUnlimitedCapacity),
mSize(0), mMaxSize(MB(DEFAULT_TEXTURE_CACHE_SIZE)),
mFlushRate(DEFAULT_TEXTURE_CACHE_FLUSH_RATE) {
char property[PROPERTY_VALUE_MAX];
@@ -61,7 +62,7 @@
}
TextureCache::TextureCache(uint32_t maxByteSize):
- mCache(LruCache<const SkPixelRef*, Texture*>::kUnlimitedCapacity),
+ mCache(LruCache<uint32_t, Texture*>::kUnlimitedCapacity),
mSize(0), mMaxSize(maxByteSize) {
init();
}
@@ -106,7 +107,7 @@
// Callbacks
///////////////////////////////////////////////////////////////////////////////
-void TextureCache::operator()(const SkPixelRef*&, Texture*& texture) {
+void TextureCache::operator()(uint32_t&, Texture*& texture) {
// This will be called already locked
if (texture) {
mSize -= texture->bitmapSize;
@@ -125,7 +126,7 @@
///////////////////////////////////////////////////////////////////////////////
void TextureCache::resetMarkInUse() {
- LruCache<const SkPixelRef*, Texture*>::Iterator iter(mCache);
+ LruCache<uint32_t, Texture*>::Iterator iter(mCache);
while (iter.next()) {
iter.value()->isInUse = false;
}
@@ -143,7 +144,7 @@
// Returns a prepared Texture* that either is already in the cache or can fit
// in the cache (and is thus added to the cache)
Texture* TextureCache::getCachedTexture(const SkBitmap* bitmap) {
- Texture* texture = mCache.get(bitmap->pixelRef());
+ Texture* texture = mCache.get(bitmap->pixelRef()->getStableID());
if (!texture) {
if (!canMakeTextureFromBitmap(bitmap)) {
@@ -173,7 +174,7 @@
if (mDebugEnabled) {
ALOGD("Texture created, size = %d", size);
}
- mCache.put(bitmap->pixelRef(), texture);
+ mCache.put(bitmap->pixelRef()->getStableID(), texture);
}
} else if (!texture->isInUse && bitmap->getGenerationID() != texture->generation) {
// Texture was in the cache but is dirty, re-upload
@@ -220,22 +221,19 @@
return texture;
}
-void TextureCache::remove(const SkBitmap* bitmap) {
- mCache.remove(bitmap->pixelRef());
-}
+void TextureCache::releaseTexture(const SkBitmap* bitmap) {
+ if (!bitmap || !bitmap->pixelRef()) return;
-void TextureCache::removeDeferred(const SkBitmap* bitmap) {
Mutex::Autolock _l(mLock);
- mGarbage.push(bitmap);
+ mGarbage.push(bitmap->pixelRef()->getStableID());
}
void TextureCache::clearGarbage() {
Mutex::Autolock _l(mLock);
size_t count = mGarbage.size();
for (size_t i = 0; i < count; i++) {
- const SkBitmap* bitmap = mGarbage.itemAt(i);
- mCache.remove(bitmap->pixelRef());
- delete bitmap;
+ uint32_t pixelRefId = mGarbage.itemAt(i);
+ mCache.remove(pixelRefId);
}
mGarbage.clear();
}
diff --git a/libs/hwui/TextureCache.h b/libs/hwui/TextureCache.h
index 668defc..1e2d741 100644
--- a/libs/hwui/TextureCache.h
+++ b/libs/hwui/TextureCache.h
@@ -50,7 +50,7 @@
* Any texture added to the cache causing the cache to grow beyond the maximum
* allowed size will also cause the oldest texture to be kicked out.
*/
-class TextureCache: public OnEntryRemoved<const SkPixelRef*, Texture*> {
+class TextureCache: public OnEntryRemoved<uint32_t, Texture*> {
public:
TextureCache();
TextureCache(uint32_t maxByteSize);
@@ -60,7 +60,7 @@
* Used as a callback when an entry is removed from the cache.
* Do not invoke directly.
*/
- void operator()(const SkPixelRef*& pixelRef, Texture*& texture);
+ void operator()(uint32_t&, Texture*& texture);
/**
* Resets all Textures to not be marked as in use
@@ -84,16 +84,12 @@
* texture is not kept in the cache. The caller must destroy the texture.
*/
Texture* getTransient(const SkBitmap* bitmap);
- /**
- * Removes the texture associated with the specified bitmap.
- * Upon remove the texture is freed.
- */
- void remove(const SkBitmap* bitmap);
+
/**
* Removes the texture associated with the specified bitmap. This is meant
* to be called from threads that are not the EGL context thread.
*/
- void removeDeferred(const SkBitmap* bitmap);
+ void releaseTexture(const SkBitmap* bitmap);
/**
* Process deferred removals.
*/
@@ -148,7 +144,7 @@
void init();
- LruCache<const SkPixelRef*, Texture*> mCache;
+ LruCache<uint32_t, Texture*> mCache;
uint32_t mSize;
uint32_t mMaxSize;
@@ -158,7 +154,7 @@
bool mDebugEnabled;
- Vector<const SkBitmap*> mGarbage;
+ Vector<uint32_t> mGarbage;
mutable Mutex mLock;
}; // class TextureCache