2008-12-17 15:59:43 +00:00
|
|
|
/*
|
2011-07-28 14:26:00 +00:00
|
|
|
* Copyright 2008 The Android Open Source Project
|
2008-12-17 15:59:43 +00:00
|
|
|
*
|
2011-07-28 14:26:00 +00:00
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
2008-12-17 15:59:43 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef SkPixelRef_DEFINED
|
|
|
|
#define SkPixelRef_DEFINED
|
|
|
|
|
2011-12-02 19:11:17 +00:00
|
|
|
#include "SkBitmap.h"
|
2014-07-08 19:30:39 +00:00
|
|
|
#include "SkDynamicAnnotations.h"
|
2008-12-17 15:59:43 +00:00
|
|
|
#include "SkRefCnt.h"
|
|
|
|
#include "SkString.h"
|
2012-03-28 20:47:01 +00:00
|
|
|
#include "SkFlattenable.h"
|
2014-01-06 17:08:27 +00:00
|
|
|
#include "SkImageInfo.h"
|
2013-10-24 17:44:27 +00:00
|
|
|
#include "SkTDArray.h"
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2014-01-13 14:53:55 +00:00
|
|
|
//#define xed
|
2014-01-06 17:08:27 +00:00
|
|
|
|
2012-12-13 21:41:00 +00:00
|
|
|
#ifdef SK_DEBUG
|
|
|
|
/**
|
|
|
|
* Defining SK_IGNORE_PIXELREF_SETPRELOCKED will force all pixelref
|
|
|
|
* subclasses to correctly handle lock/unlock pixels. For performance
|
|
|
|
* reasons, simple malloc-based subclasses call setPreLocked() to skip
|
|
|
|
* the overhead of implementing these calls.
|
|
|
|
*
|
|
|
|
* This build-flag disables that optimization, to add in debugging our
|
|
|
|
* call-sites, to ensure that they correctly balance their calls of
|
|
|
|
* lock and unlock.
|
|
|
|
*/
|
|
|
|
// #define SK_IGNORE_PIXELREF_SETPRELOCKED
|
|
|
|
#endif
|
|
|
|
|
2014-07-07 21:32:06 +00:00
|
|
|
#ifdef SK_SUPPORT_LEGACY_PIXELREF_UNFLATTENABLE
|
|
|
|
// we only support unflattening, not flattening
|
|
|
|
#define SK_PIXELREF_BASECLASS SkFlattenable
|
|
|
|
#else
|
|
|
|
#define SK_PIXELREF_BASECLASS SkRefCnt
|
|
|
|
#endif
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
class SkColorTable;
|
2012-12-06 14:26:02 +00:00
|
|
|
class SkData;
|
2011-04-01 19:05:36 +00:00
|
|
|
struct SkIRect;
|
2008-12-17 15:59:43 +00:00
|
|
|
class SkMutex;
|
|
|
|
|
2013-06-26 19:18:23 +00:00
|
|
|
class GrTexture;
|
2010-09-09 16:01:26 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** \class SkPixelRef
|
|
|
|
|
|
|
|
This class is the smart container for pixel memory, and is used with
|
|
|
|
SkBitmap. A pixelref is installed into a bitmap, and then the bitmap can
|
|
|
|
access the actual pixel memory by calling lockPixels/unlockPixels.
|
|
|
|
|
|
|
|
This class can be shared/accessed between multiple threads.
|
|
|
|
*/
|
2014-07-07 21:32:06 +00:00
|
|
|
class SK_API SkPixelRef : public SK_PIXELREF_BASECLASS {
|
2008-12-17 15:59:43 +00:00
|
|
|
public:
|
2012-06-27 14:03:26 +00:00
|
|
|
SK_DECLARE_INST_COUNT(SkPixelRef)
|
|
|
|
|
2013-12-06 22:07:17 +00:00
|
|
|
explicit SkPixelRef(const SkImageInfo&);
|
2013-12-06 22:16:10 +00:00
|
|
|
SkPixelRef(const SkImageInfo&, SkBaseMutex* mutex);
|
2013-10-24 17:44:27 +00:00
|
|
|
virtual ~SkPixelRef();
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2013-12-09 22:01:03 +00:00
|
|
|
const SkImageInfo& info() const {
|
|
|
|
return fInfo;
|
|
|
|
}
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** Return the pixel memory returned from lockPixels, or null if the
|
|
|
|
lockCount is 0.
|
|
|
|
*/
|
2014-01-06 17:08:27 +00:00
|
|
|
void* pixels() const { return fRec.fPixels; }
|
2008-12-17 15:59:43 +00:00
|
|
|
|
|
|
|
/** Return the current colorTable (if any) if pixels are locked, or null.
|
|
|
|
*/
|
2014-01-06 17:08:27 +00:00
|
|
|
SkColorTable* colorTable() const { return fRec.fColorTable; }
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2014-01-08 15:42:01 +00:00
|
|
|
size_t rowBytes() const { return fRec.fRowBytes; }
|
|
|
|
|
2014-01-03 17:58:57 +00:00
|
|
|
/**
|
|
|
|
* To access the actual pixels of a pixelref, it must be "locked".
|
|
|
|
* Calling lockPixels returns a LockRec struct (on success).
|
|
|
|
*/
|
|
|
|
struct LockRec {
|
|
|
|
void* fPixels;
|
|
|
|
SkColorTable* fColorTable;
|
|
|
|
size_t fRowBytes;
|
2014-01-04 07:01:40 +00:00
|
|
|
|
2014-01-03 17:58:57 +00:00
|
|
|
void zero() { sk_bzero(this, sizeof(*this)); }
|
|
|
|
|
|
|
|
bool isZero() const {
|
|
|
|
return NULL == fPixels && NULL == fColorTable && 0 == fRowBytes;
|
|
|
|
}
|
|
|
|
};
|
2014-01-04 07:01:40 +00:00
|
|
|
|
2012-05-17 13:14:52 +00:00
|
|
|
/**
|
|
|
|
* Returns true if the lockcount > 0
|
|
|
|
*/
|
|
|
|
bool isLocked() const { return fLockCount > 0; }
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2012-12-14 13:13:55 +00:00
|
|
|
SkDEBUGCODE(int getLockCount() const { return fLockCount; })
|
|
|
|
|
2014-01-06 17:08:27 +00:00
|
|
|
/**
|
|
|
|
* Call to access the pixel memory. Return true on success. Balance this
|
|
|
|
* with a call to unlockPixels().
|
|
|
|
*/
|
|
|
|
bool lockPixels();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call to access the pixel memory. On success, return true and fill out
|
|
|
|
* the specified rec. On failure, return false and ignore the rec parameter.
|
|
|
|
* Balance this with a call to unlockPixels().
|
|
|
|
*/
|
|
|
|
bool lockPixels(LockRec* rec);
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** Call to balanace a previous call to lockPixels(). Returns the pixels
|
|
|
|
(or null) after the unlock. NOTE: lock calls can be nested, but the
|
|
|
|
matching number of unlock calls must be made in order to free the
|
|
|
|
memory (if the subclass implements caching/deferred-decoding.)
|
|
|
|
*/
|
|
|
|
void unlockPixels();
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2011-07-07 13:42:37 +00:00
|
|
|
/**
|
|
|
|
* Some bitmaps can return a copy of their pixels for lockPixels(), but
|
|
|
|
* that copy, if modified, will not be pushed back. These bitmaps should
|
|
|
|
* not be used as targets for a raster device/canvas (since all pixels
|
|
|
|
* modifications will be lost when unlockPixels() is called.)
|
|
|
|
*/
|
|
|
|
bool lockPixelsAreWritable() const;
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** 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;
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2014-01-27 15:41:07 +00:00
|
|
|
/**
|
|
|
|
* 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().
|
|
|
|
*/
|
2014-01-28 16:05:39 +00:00
|
|
|
void notifyPixelsChanged();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Change the info's AlphaType. Note that this does not automatically
|
|
|
|
* invalidate the generation ID. If the pixel values themselves have
|
|
|
|
* changed, then you must explicitly call notifyPixelsChanged() as well.
|
|
|
|
*/
|
|
|
|
void changeAlphaType(SkAlphaType at);
|
2008-12-17 15:59:43 +00:00
|
|
|
|
|
|
|
/** 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 fIsImmutable; }
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** 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();
|
|
|
|
|
|
|
|
/** Return the optional URI string associated with this pixelref. May be
|
|
|
|
null.
|
|
|
|
*/
|
|
|
|
const char* getURI() const { return fURI.size() ? fURI.c_str() : NULL; }
|
|
|
|
|
|
|
|
/** Copy a URI string to this pixelref, or clear the URI if the uri is null
|
|
|
|
*/
|
|
|
|
void setURI(const char uri[]) {
|
|
|
|
fURI.set(uri);
|
|
|
|
}
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** Copy a URI string to this pixelref
|
|
|
|
*/
|
|
|
|
void setURI(const char uri[], size_t len) {
|
|
|
|
fURI.set(uri, len);
|
|
|
|
}
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** Assign a URI string to this pixelref.
|
|
|
|
*/
|
|
|
|
void setURI(const SkString& uri) { fURI = uri; }
|
|
|
|
|
2012-12-06 14:26:02 +00:00
|
|
|
/**
|
|
|
|
* If the pixelRef has an encoded (i.e. compressed) representation,
|
|
|
|
* return a ref to its data. If the pixelRef
|
|
|
|
* is uncompressed or otherwise does not have this form, return NULL.
|
|
|
|
*
|
|
|
|
* If non-null is returned, the caller is responsible for calling unref()
|
|
|
|
* on the data when it is finished.
|
|
|
|
*/
|
|
|
|
SkData* refEncodedData() {
|
|
|
|
return this->onRefEncodedData();
|
|
|
|
}
|
|
|
|
|
2013-09-13 16:04:49 +00:00
|
|
|
/**
|
|
|
|
* Experimental -- tells the caller if it is worth it to call decodeInto().
|
|
|
|
* Just an optimization at this point, to avoid checking the cache first.
|
|
|
|
* We may remove/change this call in the future.
|
|
|
|
*/
|
|
|
|
bool implementsDecodeInto() {
|
|
|
|
return this->onImplementsDecodeInto();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a decoded instance of this pixelRef in bitmap. If this cannot be
|
|
|
|
* done, return false and the bitmap parameter is ignored/unchanged.
|
|
|
|
*
|
|
|
|
* pow2 is the requeste power-of-two downscale that the caller needs. This
|
|
|
|
* can be ignored, and the "original" size can be returned, but if the
|
|
|
|
* underlying codec can efficiently return a smaller size, that should be
|
|
|
|
* done. Some examples:
|
|
|
|
*
|
|
|
|
* To request the "base" version (original scale), pass 0 for pow2
|
|
|
|
* To request 1/2 scale version (1/2 width, 1/2 height), pass 1 for pow2
|
|
|
|
* To request 1/4 scale version (1/4 width, 1/4 height), pass 2 for pow2
|
|
|
|
* ...
|
|
|
|
*
|
|
|
|
* If this returns true, then bitmap must be "locked" such that
|
|
|
|
* bitmap->getPixels() will return the correct address.
|
|
|
|
*/
|
|
|
|
bool decodeInto(int pow2, SkBitmap* bitmap) {
|
|
|
|
SkASSERT(pow2 >= 0);
|
|
|
|
return this->onDecodeInto(pow2, bitmap);
|
|
|
|
}
|
|
|
|
|
2010-09-09 16:01:26 +00:00
|
|
|
/** Are we really wrapping a texture instead of a bitmap?
|
|
|
|
*/
|
2013-06-26 19:18:23 +00:00
|
|
|
virtual GrTexture* getTexture() { return NULL; }
|
2010-09-09 16:01:26 +00:00
|
|
|
|
2011-04-01 19:05:36 +00:00
|
|
|
bool readPixels(SkBitmap* dst, const SkIRect* subset = NULL);
|
|
|
|
|
2012-12-07 19:14:45 +00:00
|
|
|
/**
|
|
|
|
* Makes a deep copy of this PixelRef, respecting the requested config.
|
2014-06-11 13:09:50 +00:00
|
|
|
* @param colorType Desired colortype.
|
2012-12-07 19:14:45 +00:00
|
|
|
* @param subset Subset of this PixelRef to copy. Must be fully contained within the bounds of
|
|
|
|
* of this PixelRef.
|
|
|
|
* @return A new SkPixelRef, or NULL if either there is an error (e.g. the destination could
|
|
|
|
* not be created with the given config), or this PixelRef does not support deep
|
|
|
|
* copies.
|
|
|
|
*/
|
2014-06-11 13:09:50 +00:00
|
|
|
virtual SkPixelRef* deepCopy(SkColorType colortype, const SkIRect* subset) {
|
2012-12-07 19:14:45 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2011-12-02 19:11:17 +00:00
|
|
|
|
2011-11-08 19:00:26 +00:00
|
|
|
#ifdef SK_BUILD_FOR_ANDROID
|
2011-02-24 18:09:46 +00:00
|
|
|
/**
|
|
|
|
* Acquire a "global" ref on this object.
|
|
|
|
* The default implementation just calls ref(), but subclasses can override
|
|
|
|
* this method to implement additional behavior.
|
|
|
|
*/
|
2011-02-23 20:46:31 +00:00
|
|
|
virtual void globalRef(void* data=NULL);
|
|
|
|
|
2011-02-24 18:09:46 +00:00
|
|
|
/**
|
|
|
|
* Release a "global" ref on this object.
|
|
|
|
* The default implementation just calls unref(), but subclasses can override
|
|
|
|
* this method to implement additional behavior.
|
|
|
|
*/
|
2011-02-23 20:46:31 +00:00
|
|
|
virtual void globalUnref();
|
2011-02-24 18:09:46 +00:00
|
|
|
#endif
|
2011-02-23 20:46:31 +00:00
|
|
|
|
2014-07-07 21:32:06 +00:00
|
|
|
#ifdef SK_SUPPORT_LEGACY_PIXELREF_UNFLATTENABLE
|
2013-10-23 17:06:21 +00:00
|
|
|
SK_DEFINE_FLATTENABLE_TYPE(SkPixelRef)
|
2014-07-07 21:32:06 +00:00
|
|
|
#endif
|
2013-10-23 17:06:21 +00:00
|
|
|
|
2013-10-24 17:44:27 +00:00
|
|
|
// 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.
|
|
|
|
struct GenIDChangeListener {
|
|
|
|
virtual ~GenIDChangeListener() {}
|
|
|
|
virtual void onChange() = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Takes ownership of listener.
|
|
|
|
void addGenIDChangeListener(GenIDChangeListener* listener);
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
protected:
|
2014-01-06 17:08:27 +00:00
|
|
|
/**
|
|
|
|
* On success, returns true and fills out the LockRec for the pixels. On
|
|
|
|
* failure returns false and ignores the LockRec parameter.
|
|
|
|
*
|
|
|
|
* The caller will have already acquired a mutex for thread safety, so this
|
|
|
|
* method need not do that.
|
|
|
|
*/
|
|
|
|
virtual bool onNewLockPixels(LockRec*) = 0;
|
2013-12-16 07:01:40 +00:00
|
|
|
|
2013-12-13 14:18:14 +00:00
|
|
|
/**
|
2014-01-06 17:08:27 +00:00
|
|
|
* Balancing the previous successful call to onNewLockPixels. The locked
|
|
|
|
* pixel address will no longer be referenced, so the subclass is free to
|
|
|
|
* move or discard that memory.
|
2013-12-13 14:18:14 +00:00
|
|
|
*
|
2014-01-06 17:08:27 +00:00
|
|
|
* The caller will have already acquired a mutex for thread safety, so this
|
|
|
|
* method need not do that.
|
2013-12-13 13:41:14 +00:00
|
|
|
*/
|
2008-12-17 15:59:43 +00:00
|
|
|
virtual void onUnlockPixels() = 0;
|
|
|
|
|
2011-07-07 13:42:37 +00:00
|
|
|
/** Default impl returns true */
|
|
|
|
virtual bool onLockPixelsAreWritable() const;
|
|
|
|
|
2013-09-13 16:04:49 +00:00
|
|
|
// returns false;
|
|
|
|
virtual bool onImplementsDecodeInto();
|
|
|
|
// returns false;
|
|
|
|
virtual bool onDecodeInto(int pow2, SkBitmap* bitmap);
|
|
|
|
|
2011-04-01 19:05:36 +00:00
|
|
|
/**
|
|
|
|
* For pixelrefs that don't have access to their raw pixels, they may be
|
|
|
|
* able to make a copy of them (e.g. if the pixels are on the GPU).
|
|
|
|
*
|
|
|
|
* The base class implementation returns false;
|
|
|
|
*/
|
|
|
|
virtual bool onReadPixels(SkBitmap* dst, const SkIRect* subsetOrNull);
|
|
|
|
|
2012-12-06 14:26:02 +00:00
|
|
|
// default impl returns NULL.
|
|
|
|
virtual SkData* onRefEncodedData();
|
|
|
|
|
2013-12-04 17:06:49 +00:00
|
|
|
/**
|
|
|
|
* Returns the size (in bytes) of the internally allocated memory.
|
|
|
|
* This should be implemented in all serializable SkPixelRef derived classes.
|
|
|
|
* SkBitmap::fPixelRefOffset + SkBitmap::getSafeSize() should never overflow this value,
|
|
|
|
* otherwise the rendering code may attempt to read memory out of bounds.
|
|
|
|
*
|
|
|
|
* @return default impl returns 0.
|
|
|
|
*/
|
|
|
|
virtual size_t getAllocatedSizeInBytes() const;
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
/** Return the mutex associated with this pixelref. This value is assigned
|
|
|
|
in the constructor, and cannot change during the lifetime of the object.
|
|
|
|
*/
|
2012-01-26 21:26:40 +00:00
|
|
|
SkBaseMutex* mutex() const { return fMutex; }
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2012-03-29 15:18:04 +00:00
|
|
|
// serialization
|
2014-01-30 18:58:24 +00:00
|
|
|
SkPixelRef(SkReadBuffer&, SkBaseMutex*);
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2012-05-17 13:14:52 +00:00
|
|
|
// only call from constructor. Flags this to always be locked, removing
|
|
|
|
// the need to grab the mutex and call onLockPixels/onUnlockPixels.
|
|
|
|
// Performance tweak to avoid those calls (esp. in multi-thread use case).
|
2014-01-06 17:08:27 +00:00
|
|
|
void setPreLocked(void*, size_t rowBytes, SkColorTable*);
|
2012-05-17 13:14:52 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
private:
|
2012-01-26 21:26:40 +00:00
|
|
|
SkBaseMutex* fMutex; // must remain in scope for the life of this object
|
2014-01-02 18:07:46 +00:00
|
|
|
|
2014-01-27 15:41:07 +00:00
|
|
|
// mostly const. fInfo.fAlpahType can be changed at runtime.
|
2014-01-02 18:07:46 +00:00
|
|
|
const SkImageInfo fInfo;
|
2013-12-13 15:24:37 +00:00
|
|
|
|
2014-01-06 17:08:27 +00:00
|
|
|
// LockRec is only valid if we're in a locked state (isLocked())
|
|
|
|
LockRec fRec;
|
2008-12-17 15:59:43 +00:00
|
|
|
int fLockCount;
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2014-07-08 19:30:39 +00:00
|
|
|
mutable SkTRacy<uint32_t> fGenerationID;
|
|
|
|
mutable SkTRacy<bool> fUniqueGenerationID;
|
2011-02-24 18:09:46 +00:00
|
|
|
|
2013-10-24 17:44:27 +00:00
|
|
|
SkTDArray<GenIDChangeListener*> fGenIDChangeListeners; // pointers are owned
|
2012-08-22 15:00:05 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
SkString fURI;
|
|
|
|
|
|
|
|
// can go from false to true, but never from true to false
|
|
|
|
bool fIsImmutable;
|
2012-05-17 13:14:52 +00:00
|
|
|
// only ever set in constructor, const after that
|
|
|
|
bool fPreLocked;
|
|
|
|
|
2013-10-24 17:44:27 +00:00
|
|
|
void needsNewGenID();
|
|
|
|
void callGenIDChangeListeners();
|
|
|
|
|
2012-05-17 13:14:52 +00:00
|
|
|
void setMutex(SkBaseMutex* mutex);
|
2011-12-20 20:26:56 +00:00
|
|
|
|
2013-10-24 17:44:27 +00:00
|
|
|
// When copying a bitmap to another with the same shape and config, we can safely
|
|
|
|
// clone the pixelref generation ID too, which makes them equivalent under caching.
|
|
|
|
friend class SkBitmap; // only for cloneGenID
|
|
|
|
void cloneGenID(const SkPixelRef&);
|
|
|
|
|
2014-07-07 21:32:06 +00:00
|
|
|
#ifdef SK_SUPPORT_LEGACY_PIXELREF_UNFLATTENABLE
|
|
|
|
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE { sk_throw(); }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef SK_PIXELREF_BASECLASS INHERITED;
|
2008-12-17 15:59:43 +00:00
|
|
|
};
|
|
|
|
|
2014-01-24 18:53:42 +00:00
|
|
|
class SkPixelRefFactory : public SkRefCnt {
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Allocate a new pixelref matching the specified ImageInfo, allocating
|
|
|
|
* the memory for the pixels. If the ImageInfo requires a ColorTable,
|
|
|
|
* the pixelref will ref() the colortable.
|
|
|
|
* On failure return NULL.
|
|
|
|
*/
|
2014-07-01 19:48:11 +00:00
|
|
|
virtual SkPixelRef* create(const SkImageInfo&, size_t rowBytes, SkColorTable*) = 0;
|
2014-01-24 18:53:42 +00:00
|
|
|
};
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
#endif
|