e4601b0864
This fixes a bug with the following sequence: Make SkSurface_Raster, draw to it snap an image, A, from the surface make image B by calling withDefaultMipmaps() on image A Let image A be destroyed. draw to surface again snap another image, C, from the surface Image C and image B would now share the same SkPixelRef, reflecting the final contents of the SkSurface. Add a GM that exercises the bug when run through either the pic- or serialize- vias and DDL. Bug: skia:13111 Change-Id: Ib079163c84f420baf62fa7960110386303b8fb93 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/525517 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Brian Salomon <bsalomon@google.com>
126 lines
4.4 KiB
C++
126 lines
4.4 KiB
C++
/*
|
|
* Copyright 2008 The Android Open Source Project
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#ifndef SkPixelRef_DEFINED
|
|
#define SkPixelRef_DEFINED
|
|
|
|
#include "include/core/SkBitmap.h"
|
|
#include "include/core/SkImageInfo.h"
|
|
#include "include/core/SkPixmap.h"
|
|
#include "include/core/SkRefCnt.h"
|
|
#include "include/core/SkSize.h"
|
|
#include "include/private/SkIDChangeListener.h"
|
|
#include "include/private/SkMutex.h"
|
|
#include "include/private/SkTDArray.h"
|
|
|
|
#include <atomic>
|
|
|
|
struct SkIRect;
|
|
|
|
class GrTexture;
|
|
class SkDiscardableMemory;
|
|
|
|
/** \class SkPixelRef
|
|
|
|
This class is the smart container for pixel memory, and is used with SkBitmap.
|
|
This class can be shared/accessed between multiple threads.
|
|
*/
|
|
class SK_API SkPixelRef : public SkRefCnt {
|
|
public:
|
|
SkPixelRef(int width, int height, void* addr, size_t rowBytes);
|
|
~SkPixelRef() override;
|
|
|
|
SkISize dimensions() const { return {fWidth, fHeight}; }
|
|
int width() const { return fWidth; }
|
|
int height() const { return fHeight; }
|
|
void* pixels() const { return fPixels; }
|
|
size_t rowBytes() const { return fRowBytes; }
|
|
|
|
/** Returns a non-zero, unique value corresponding to the pixels in this
|
|
pixelref. Each time the pixels are changed (and notifyPixelsChanged is
|
|
called), a different generation ID will be returned.
|
|
*/
|
|
uint32_t getGenerationID() const;
|
|
|
|
/**
|
|
* Call this if you have changed the contents of the pixels. This will in-
|
|
* turn cause a different generation ID value to be returned from
|
|
* getGenerationID().
|
|
*/
|
|
void notifyPixelsChanged();
|
|
|
|
/** Returns true if this pixelref is marked as immutable, meaning that the
|
|
contents of its pixels will not change for the lifetime of the pixelref.
|
|
*/
|
|
bool isImmutable() const { return fMutability != kMutable; }
|
|
|
|
/** Marks this pixelref is immutable, meaning that the contents of its
|
|
pixels will not change for the lifetime of the pixelref. This state can
|
|
be set on a pixelref, but it cannot be cleared once it is set.
|
|
*/
|
|
void setImmutable();
|
|
|
|
// Register a listener that may be called the next time our generation ID changes.
|
|
//
|
|
// We'll only call the listener if we're confident that we are the only SkPixelRef with this
|
|
// generation ID. If our generation ID changes and we decide not to call the listener, we'll
|
|
// never call it: you must add a new listener for each generation ID change. We also won't call
|
|
// the listener when we're certain no one knows what our generation ID is.
|
|
//
|
|
// This can be used to invalidate caches keyed by SkPixelRef generation ID.
|
|
// Takes ownership of listener. Threadsafe.
|
|
void addGenIDChangeListener(sk_sp<SkIDChangeListener> listener);
|
|
|
|
// Call when this pixelref is part of the key to a resourcecache entry. This allows the cache
|
|
// to know automatically those entries can be purged when this pixelref is changed or deleted.
|
|
void notifyAddedToCache() {
|
|
fAddedToCache.store(true);
|
|
}
|
|
|
|
virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return nullptr; }
|
|
|
|
protected:
|
|
void android_only_reset(int width, int height, size_t rowBytes);
|
|
|
|
private:
|
|
int fWidth;
|
|
int fHeight;
|
|
void* fPixels;
|
|
size_t fRowBytes;
|
|
|
|
// Bottom bit indicates the Gen ID is unique.
|
|
bool genIDIsUnique() const { return SkToBool(fTaggedGenID.load() & 1); }
|
|
mutable std::atomic<uint32_t> fTaggedGenID;
|
|
|
|
SkIDChangeListener::List fGenIDChangeListeners;
|
|
|
|
// Set true by caches when they cache content that's derived from the current pixels.
|
|
std::atomic<bool> fAddedToCache;
|
|
|
|
enum Mutability {
|
|
kMutable, // PixelRefs begin mutable.
|
|
kTemporarilyImmutable, // Considered immutable, but can revert to mutable.
|
|
kImmutable, // Once set to this state, it never leaves.
|
|
} fMutability : 8; // easily fits inside a byte
|
|
|
|
void needsNewGenID();
|
|
void callGenIDChangeListeners();
|
|
|
|
void setTemporarilyImmutable();
|
|
void restoreMutability();
|
|
bool isTemporarilyImmutable();
|
|
friend class SkSurface_Raster; // For temporary immutable methods above.
|
|
friend class SkImage_Raster; // For temporary immutable methods above.
|
|
|
|
void setImmutableWithID(uint32_t genID);
|
|
friend void SkBitmapCache_setImmutableWithID(SkPixelRef*, uint32_t);
|
|
|
|
using INHERITED = SkRefCnt;
|
|
};
|
|
|
|
#endif
|