skia2/include/core/SkPixmap.h

298 lines
10 KiB
C++

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkPixmap_DEFINED
#define SkPixmap_DEFINED
#include "SkColor.h"
#include "SkFilterQuality.h"
#include "SkImageInfo.h"
class SkColorTable;
class SkData;
struct SkMask;
/**
* Pairs SkImageInfo with actual pixels and rowbytes. This class does not try to manage the
* lifetime of the pixel memory (nor the colortable if provided).
*/
class SK_API SkPixmap {
public:
SkPixmap()
: fPixels(NULL), fCTable(NULL), fRowBytes(0), fInfo(SkImageInfo::MakeUnknown(0, 0))
{}
SkPixmap(const SkImageInfo& info, const void* addr, size_t rowBytes,
SkColorTable* ctable = NULL)
: fPixels(addr), fCTable(ctable), fRowBytes(rowBytes), fInfo(info)
{
if (kIndex_8_SkColorType == info.colorType()) {
SkASSERT(ctable);
} else {
SkASSERT(NULL == ctable);
}
}
void reset();
void reset(const SkImageInfo& info, const void* addr, size_t rowBytes,
SkColorTable* ctable = NULL);
void reset(const SkImageInfo& info) {
this->reset(info, NULL, 0, NULL);
}
/**
* If supported, set this pixmap to point to the pixels in the specified mask and return true.
* On failure, return false and set this pixmap to empty.
*/
bool SK_WARN_UNUSED_RESULT reset(const SkMask&);
/**
* Computes the intersection of area and this pixmap. If that intersection is non-empty,
* set subset to that intersection and return true.
*
* On failure, return false and ignore the subset parameter.
*/
bool SK_WARN_UNUSED_RESULT extractSubset(SkPixmap* subset, const SkIRect& area) const;
const SkImageInfo& info() const { return fInfo; }
size_t rowBytes() const { return fRowBytes; }
const void* addr() const { return fPixels; }
SkColorTable* ctable() const { return fCTable; }
int width() const { return fInfo.width(); }
int height() const { return fInfo.height(); }
SkColorType colorType() const { return fInfo.colorType(); }
SkAlphaType alphaType() const { return fInfo.alphaType(); }
bool isOpaque() const { return fInfo.isOpaque(); }
SkIRect bounds() const { return SkIRect::MakeWH(this->width(), this->height()); }
uint64_t getSize64() const { return sk_64_mul(fInfo.height(), fRowBytes); }
uint64_t getSafeSize64() const { return fInfo.getSafeSize64(fRowBytes); }
size_t getSafeSize() const { return fInfo.getSafeSize(fRowBytes); }
const void* addr(int x, int y) const {
return (const char*)fPixels + fInfo.computeOffset(x, y, fRowBytes);
}
const uint8_t* addr8() const {
SkASSERT(1 == SkColorTypeBytesPerPixel(fInfo.colorType()));
return reinterpret_cast<const uint8_t*>(fPixels);
}
const uint16_t* addr16() const {
SkASSERT(2 == SkColorTypeBytesPerPixel(fInfo.colorType()));
return reinterpret_cast<const uint16_t*>(fPixels);
}
const uint32_t* addr32() const {
SkASSERT(4 == SkColorTypeBytesPerPixel(fInfo.colorType()));
return reinterpret_cast<const uint32_t*>(fPixels);
}
const uint64_t* addr64() const {
SkASSERT(8 == SkColorTypeBytesPerPixel(fInfo.colorType()));
return reinterpret_cast<const uint64_t*>(fPixels);
}
const uint16_t* addrF16() const {
SkASSERT(8 == SkColorTypeBytesPerPixel(fInfo.colorType()));
SkASSERT(kRGBA_F16_SkColorType == fInfo.colorType());
return reinterpret_cast<const uint16_t*>(fPixels);
}
// Offset by the specified x,y coordinates
const uint8_t* addr8(int x, int y) const {
SkASSERT((unsigned)x < (unsigned)fInfo.width());
SkASSERT((unsigned)y < (unsigned)fInfo.height());
return (const uint8_t*)((const char*)this->addr8() + y * fRowBytes + (x << 0));
}
const uint16_t* addr16(int x, int y) const {
SkASSERT((unsigned)x < (unsigned)fInfo.width());
SkASSERT((unsigned)y < (unsigned)fInfo.height());
return (const uint16_t*)((const char*)this->addr16() + y * fRowBytes + (x << 1));
}
const uint32_t* addr32(int x, int y) const {
SkASSERT((unsigned)x < (unsigned)fInfo.width());
SkASSERT((unsigned)y < (unsigned)fInfo.height());
return (const uint32_t*)((const char*)this->addr32() + y * fRowBytes + (x << 2));
}
const uint64_t* addr64(int x, int y) const {
SkASSERT((unsigned)x < (unsigned)fInfo.width());
SkASSERT((unsigned)y < (unsigned)fInfo.height());
return (const uint64_t*)((const char*)this->addr64() + y * fRowBytes + (x << 3));
}
const uint16_t* addrF16(int x, int y) const {
SkASSERT(kRGBA_F16_SkColorType == fInfo.colorType());
return reinterpret_cast<const uint16_t*>(this->addr64(x, y));
}
// Writable versions
void* writable_addr() const { return const_cast<void*>(fPixels); }
uint8_t* writable_addr8(int x, int y) const {
return const_cast<uint8_t*>(this->addr8(x, y));
}
uint16_t* writable_addr16(int x, int y) const {
return const_cast<uint16_t*>(this->addr16(x, y));
}
uint32_t* writable_addr32(int x, int y) const {
return const_cast<uint32_t*>(this->addr32(x, y));
}
uint64_t* writable_addr64(int x, int y) const {
return const_cast<uint64_t*>(this->addr64(x, y));
}
uint16_t* writable_addrF16(int x, int y) const {
return reinterpret_cast<uint16_t*>(writable_addr64(x, y));
}
// copy methods
bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
int srcX, int srcY) const;
bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes) const {
return this->readPixels(dstInfo, dstPixels, dstRowBytes, 0, 0);
}
bool readPixels(const SkPixmap& dst, int srcX, int srcY) const {
return this->readPixels(dst.info(), dst.writable_addr(), dst.rowBytes(), srcX, srcY);
}
bool readPixels(const SkPixmap& dst) const {
return this->readPixels(dst.info(), dst.writable_addr(), dst.rowBytes(), 0, 0);
}
/**
* Copy the pixels from this pixmap into the dst pixmap, converting as needed into dst's
* colortype/alphatype. If the conversion cannot be performed, false is returned.
*
* If dst's dimensions differ from the src dimension, the image will be scaled, applying the
* specified filter-quality.
*/
bool scalePixels(const SkPixmap& dst, SkFilterQuality) const;
/**
* Returns true if pixels were written to (e.g. if colorType is kUnknown_SkColorType, this
* will return false). If subset does not intersect the bounds of this pixmap, returns false.
*/
bool erase(SkColor, const SkIRect& subset) const;
bool erase(SkColor color) const { return this->erase(color, this->bounds()); }
bool erase(const SkColor4f&, const SkIRect* subset = nullptr) const;
private:
const void* fPixels;
SkColorTable* fCTable;
size_t fRowBytes;
SkImageInfo fInfo;
};
/////////////////////////////////////////////////////////////////////////////////////////////
class SK_API SkAutoPixmapStorage : public SkPixmap {
public:
SkAutoPixmapStorage();
~SkAutoPixmapStorage();
/**
* Try to allocate memory for the pixels needed to match the specified Info. On success
* return true and fill out the pixmap to point to that memory. The storage will be freed
* when this object is destroyed, or if another call to tryAlloc() or alloc() is made.
*
* On failure, return false and reset() the pixmap to empty.
*/
bool tryAlloc(const SkImageInfo&);
/**
* Allocate memory for the pixels needed to match the specified Info and fill out the pixmap
* to point to that memory. The storage will be freed when this object is destroyed,
* or if another call to tryAlloc() or alloc() is made.
*
* If the memory cannot be allocated, calls sk_throw().
*/
void alloc(const SkImageInfo&);
/**
* Returns an SkData object wrapping the allocated pixels memory, and resets the pixmap.
* If the storage hasn't been allocated, the result is NULL.
*/
const SkData* SK_WARN_UNUSED_RESULT detachPixelsAsData();
// We wrap these so we can clear our internal storage
void reset() {
this->freeStorage();
this->INHERITED::reset();
}
void reset(const SkImageInfo& info, const void* addr, size_t rb, SkColorTable* ctable = NULL) {
this->freeStorage();
this->INHERITED::reset(info, addr, rb, ctable);
}
void reset(const SkImageInfo& info) {
this->freeStorage();
this->INHERITED::reset(info);
}
bool SK_WARN_UNUSED_RESULT reset(const SkMask& mask) {
this->freeStorage();
return this->INHERITED::reset(mask);
}
private:
void* fStorage;
void freeStorage() {
sk_free(fStorage);
fStorage = nullptr;
}
typedef SkPixmap INHERITED;
};
/////////////////////////////////////////////////////////////////////////////////////////////
class SK_API SkAutoPixmapUnlock : ::SkNoncopyable {
public:
SkAutoPixmapUnlock() : fUnlockProc(NULL), fIsLocked(false) {}
SkAutoPixmapUnlock(const SkPixmap& pm, void (*unlock)(void*), void* ctx)
: fUnlockProc(unlock), fUnlockContext(ctx), fPixmap(pm), fIsLocked(true)
{}
~SkAutoPixmapUnlock() { this->unlock(); }
/**
* Return the currently locked pixmap. Undefined if it has been unlocked.
*/
const SkPixmap& pixmap() const {
SkASSERT(this->isLocked());
return fPixmap;
}
bool isLocked() const { return fIsLocked; }
/**
* Unlocks the pixmap. Can safely be called more than once as it will only call the underlying
* unlock-proc once.
*/
void unlock() {
if (fUnlockProc) {
SkASSERT(fIsLocked);
fUnlockProc(fUnlockContext);
fUnlockProc = NULL;
fIsLocked = false;
}
}
/**
* If there is a currently locked pixmap, unlock it, then copy the specified pixmap
* and (optional) unlock proc/context.
*/
void reset(const SkPixmap& pm, void (*unlock)(void*), void* ctx);
private:
void (*fUnlockProc)(void*);
void* fUnlockContext;
SkPixmap fPixmap;
bool fIsLocked;
friend class SkBitmap;
};
#endif