| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkBitmapCache.h" |
| #include "SkMutex.h" |
| #include "SkPixelRef.h" |
| #include "SkTraceEvent.h" |
| |
| //#define SK_SUPPORT_LEGACY_UNBALANCED_PIXELREF_LOCKCOUNT |
| //#define SK_TRACE_PIXELREF_LIFETIME |
| |
| #include "SkNextID.h" |
| |
| uint32_t SkNextID::ImageID() { |
| static uint32_t gID = 0; |
| uint32_t id; |
| // Loop in case our global wraps around, as we never want to return a 0. |
| do { |
| id = sk_atomic_fetch_add(&gID, 2u) + 2; // Never set the low bit. |
| } while (0 == id); |
| return id; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // just need a > 0 value, so pick a funny one to aid in debugging |
| #define SKPIXELREF_PRELOCKED_LOCKCOUNT 123456789 |
| |
| static SkImageInfo validate_info(const SkImageInfo& info) { |
| SkAlphaType newAlphaType = info.alphaType(); |
| SkAssertResult(SkColorTypeValidateAlphaType(info.colorType(), info.alphaType(), &newAlphaType)); |
| return info.makeAlphaType(newAlphaType); |
| } |
| |
| #ifdef SK_TRACE_PIXELREF_LIFETIME |
| static int32_t gInstCounter; |
| #endif |
| |
| SkPixelRef::SkPixelRef(const SkImageInfo& info) |
| : fInfo(validate_info(info)) |
| #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| , fStableID(SkNextID::ImageID()) |
| #endif |
| |
| { |
| #ifdef SK_TRACE_PIXELREF_LIFETIME |
| SkDebugf(" pixelref %d\n", sk_atomic_inc(&gInstCounter)); |
| #endif |
| fRec.zero(); |
| fLockCount = 0; |
| this->needsNewGenID(); |
| fMutability = kMutable; |
| fPreLocked = false; |
| fAddedToCache.store(false); |
| } |
| |
| SkPixelRef::~SkPixelRef() { |
| #ifndef SK_SUPPORT_LEGACY_UNBALANCED_PIXELREF_LOCKCOUNT |
| SkASSERT(SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount || 0 == fLockCount); |
| #endif |
| |
| #ifdef SK_TRACE_PIXELREF_LIFETIME |
| SkDebugf("~pixelref %d\n", sk_atomic_dec(&gInstCounter) - 1); |
| #endif |
| this->callGenIDChangeListeners(); |
| } |
| |
| void SkPixelRef::needsNewGenID() { |
| fTaggedGenID.store(0); |
| SkASSERT(!this->genIDIsUnique()); // This method isn't threadsafe, so the assert should be fine. |
| } |
| |
| void SkPixelRef::cloneGenID(const SkPixelRef& that) { |
| // This is subtle. We must call that.getGenerationID() to make sure its genID isn't 0. |
| uint32_t genID = that.getGenerationID(); |
| |
| // Neither ID is unique any more. |
| // (These & ~1u are actually redundant. that.getGenerationID() just did it for us.) |
| this->fTaggedGenID.store(genID & ~1u); |
| that. fTaggedGenID.store(genID & ~1u); |
| |
| // This method isn't threadsafe, so these asserts should be fine. |
| SkASSERT(!this->genIDIsUnique()); |
| SkASSERT(!that. genIDIsUnique()); |
| } |
| |
| static void validate_pixels_ctable(const SkImageInfo& info, const SkColorTable* ctable) { |
| if (info.isEmpty()) { |
| return; // can't require ctable if the dimensions are empty |
| } |
| if (kIndex_8_SkColorType == info.colorType()) { |
| SkASSERT(ctable); |
| } else { |
| SkASSERT(nullptr == ctable); |
| } |
| } |
| |
| void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) { |
| SkASSERT(pixels); |
| validate_pixels_ctable(fInfo, ctable); |
| // only call me in your constructor, otherwise fLockCount tracking can get |
| // out of sync. |
| fRec.fPixels = pixels; |
| fRec.fColorTable = ctable; |
| fRec.fRowBytes = rowBytes; |
| fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT; |
| fPreLocked = true; |
| } |
| |
| // Increments fLockCount only on success |
| bool SkPixelRef::lockPixelsInsideMutex() { |
| fMutex.assertHeld(); |
| |
| if (1 == ++fLockCount) { |
| SkASSERT(fRec.isZero()); |
| if (!this->onNewLockPixels(&fRec)) { |
| fRec.zero(); |
| fLockCount -= 1; // we return fLockCount unchanged if we fail. |
| return false; |
| } |
| } |
| if (fRec.fPixels) { |
| validate_pixels_ctable(fInfo, fRec.fColorTable); |
| return true; |
| } |
| // no pixels, so we failed (somehow) |
| --fLockCount; |
| return false; |
| } |
| |
| // For historical reasons, we always inc fLockCount, even if we return false. |
| // It would be nice to change this (it seems), and only inc if we actually succeed... |
| bool SkPixelRef::lockPixels() { |
| SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount); |
| |
| if (!fPreLocked) { |
| TRACE_EVENT_BEGIN0("skia", "SkPixelRef::lockPixelsMutex"); |
| SkAutoMutexAcquire ac(fMutex); |
| TRACE_EVENT_END0("skia", "SkPixelRef::lockPixelsMutex"); |
| SkDEBUGCODE(int oldCount = fLockCount;) |
| bool success = this->lockPixelsInsideMutex(); |
| // lockPixelsInsideMutex only increments the count if it succeeds. |
| SkASSERT(oldCount + (int)success == fLockCount); |
| |
| if (!success) { |
| // For compatibility with SkBitmap calling lockPixels, we still want to increment |
| // fLockCount even if we failed. If we updated SkBitmap we could remove this oddity. |
| fLockCount += 1; |
| return false; |
| } |
| } |
| if (fRec.fPixels) { |
| validate_pixels_ctable(fInfo, fRec.fColorTable); |
| return true; |
| } |
| return false; |
| } |
| |
| bool SkPixelRef::lockPixels(LockRec* rec) { |
| if (this->lockPixels()) { |
| *rec = fRec; |
| return true; |
| } |
| return false; |
| } |
| |
| void SkPixelRef::unlockPixels() { |
| SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount); |
| |
| if (!fPreLocked) { |
| SkAutoMutexAcquire ac(fMutex); |
| |
| SkASSERT(fLockCount > 0); |
| if (0 == --fLockCount) { |
| // don't call onUnlockPixels unless onLockPixels succeeded |
| if (fRec.fPixels) { |
| this->onUnlockPixels(); |
| fRec.zero(); |
| } else { |
| SkASSERT(fRec.isZero()); |
| } |
| } |
| } |
| } |
| |
| bool SkPixelRef::requestLock(const LockRequest& request, LockResult* result) { |
| SkASSERT(result); |
| if (request.fSize.isEmpty()) { |
| return false; |
| } |
| // until we support subsets, we have to check this... |
| if (request.fSize.width() != fInfo.width() || request.fSize.height() != fInfo.height()) { |
| return false; |
| } |
| |
| if (fPreLocked) { |
| result->fUnlockProc = nullptr; |
| result->fUnlockContext = nullptr; |
| result->fCTable = fRec.fColorTable; |
| result->fPixels = fRec.fPixels; |
| result->fRowBytes = fRec.fRowBytes; |
| result->fSize.set(fInfo.width(), fInfo.height()); |
| } else { |
| SkAutoMutexAcquire ac(fMutex); |
| if (!this->onRequestLock(request, result)) { |
| return false; |
| } |
| } |
| if (result->fPixels) { |
| validate_pixels_ctable(fInfo, result->fCTable); |
| return true; |
| } |
| return false; |
| } |
| |
| bool SkPixelRef::lockPixelsAreWritable() const { |
| return this->onLockPixelsAreWritable(); |
| } |
| |
| bool SkPixelRef::onLockPixelsAreWritable() const { |
| return true; |
| } |
| |
| uint32_t SkPixelRef::getGenerationID() const { |
| uint32_t id = fTaggedGenID.load(); |
| if (0 == id) { |
| uint32_t next = SkNextID::ImageID() | 1u; |
| if (fTaggedGenID.compare_exchange(&id, next)) { |
| id = next; // There was no race or we won the race. fTaggedGenID is next now. |
| } else { |
| // We lost a race to set fTaggedGenID. compare_exchange() filled id with the winner. |
| } |
| // We can't quite SkASSERT(this->genIDIsUnique()). It could be non-unique |
| // if we got here via the else path (pretty unlikely, but possible). |
| } |
| return id & ~1u; // Mask off bottom unique bit. |
| } |
| |
| void SkPixelRef::addGenIDChangeListener(GenIDChangeListener* listener) { |
| if (nullptr == listener || !this->genIDIsUnique()) { |
| // No point in tracking this if we're not going to call it. |
| delete listener; |
| return; |
| } |
| *fGenIDChangeListeners.append() = listener; |
| } |
| |
| // we need to be called *before* the genID gets changed or zerod |
| void SkPixelRef::callGenIDChangeListeners() { |
| // We don't invalidate ourselves if we think another SkPixelRef is sharing our genID. |
| if (this->genIDIsUnique()) { |
| for (int i = 0; i < fGenIDChangeListeners.count(); i++) { |
| fGenIDChangeListeners[i]->onChange(); |
| } |
| |
| // TODO: SkAtomic could add "old_value = atomic.xchg(new_value)" to make this clearer. |
| if (fAddedToCache.load()) { |
| SkNotifyBitmapGenIDIsStale(this->getGenerationID()); |
| fAddedToCache.store(false); |
| } |
| } |
| // Listeners get at most one shot, so whether these triggered or not, blow them away. |
| fGenIDChangeListeners.deleteAll(); |
| } |
| |
| void SkPixelRef::notifyPixelsChanged() { |
| #ifdef SK_DEBUG |
| if (this->isImmutable()) { |
| SkDebugf("========== notifyPixelsChanged called on immutable pixelref"); |
| } |
| #endif |
| this->callGenIDChangeListeners(); |
| this->needsNewGenID(); |
| this->onNotifyPixelsChanged(); |
| } |
| |
| void SkPixelRef::changeAlphaType(SkAlphaType at) { |
| *const_cast<SkImageInfo*>(&fInfo) = fInfo.makeAlphaType(at); |
| } |
| |
| void SkPixelRef::setImmutable() { |
| fMutability = kImmutable; |
| } |
| |
| void SkPixelRef::setImmutableWithID(uint32_t genID) { |
| /* |
| * We are forcing the genID to match an external value. The caller must ensure that this |
| * value does not conflict with other content. |
| * |
| * One use is to force this pixelref's id to match an SkImage's id |
| */ |
| fMutability = kImmutable; |
| fTaggedGenID.store(genID); |
| } |
| |
| void SkPixelRef::setTemporarilyImmutable() { |
| SkASSERT(fMutability != kImmutable); |
| fMutability = kTemporarilyImmutable; |
| } |
| |
| void SkPixelRef::restoreMutability() { |
| SkASSERT(fMutability != kImmutable); |
| fMutability = kMutable; |
| } |
| |
| bool SkPixelRef::readPixels(SkBitmap* dst, SkColorType ct, const SkIRect* subset) { |
| return this->onReadPixels(dst, ct, subset); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| bool SkPixelRef::onReadPixels(SkBitmap* dst, SkColorType, const SkIRect* subset) { |
| return false; |
| } |
| |
| void SkPixelRef::onNotifyPixelsChanged() { } |
| |
| SkData* SkPixelRef::onRefEncodedData() { |
| return nullptr; |
| } |
| |
| bool SkPixelRef::onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3], |
| SkYUVColorSpace* colorSpace) { |
| return false; |
| } |
| |
| size_t SkPixelRef::getAllocatedSizeInBytes() const { |
| return 0; |
| } |
| |
| static void unlock_legacy_result(void* ctx) { |
| SkPixelRef* pr = (SkPixelRef*)ctx; |
| pr->unlockPixels(); |
| pr->unref(); // balancing the Ref in onRequestLoc |
| } |
| |
| bool SkPixelRef::onRequestLock(const LockRequest& request, LockResult* result) { |
| if (!this->lockPixelsInsideMutex()) { |
| return false; |
| } |
| |
| result->fUnlockProc = unlock_legacy_result; |
| result->fUnlockContext = SkRef(this); // this is balanced in our fUnlockProc |
| result->fCTable = fRec.fColorTable; |
| result->fPixels = fRec.fPixels; |
| result->fRowBytes = fRec.fRowBytes; |
| result->fSize.set(fInfo.width(), fInfo.height()); |
| return true; |
| } |