8 #ifndef SkPixmap_DEFINED
9 #define SkPixmap_DEFINED
12 #include "SkFilterQuality.h"
13 #include "SkImageInfo.h"
26 : fPixels(NULL), fCTable(NULL), fRowBytes(0), fInfo(SkImageInfo::MakeUnknown(0, 0))
31 : fPixels(addr), fCTable(ctable), fRowBytes(rowBytes), fInfo(info)
33 if (kIndex_8_SkColorType == info.colorType()) {
36 SkASSERT(NULL == ctable);
41 void reset(
const SkImageInfo& info,
const void* addr,
size_t rowBytes,
44 this->reset(info, NULL, 0, NULL);
54 bool SK_WARN_UNUSED_RESULT reset(
const SkMask&);
62 bool SK_WARN_UNUSED_RESULT extractSubset(
SkPixmap* subset,
const SkIRect& area)
const;
65 size_t rowBytes()
const {
return fRowBytes; }
66 const void* addr()
const {
return fPixels; }
69 int width()
const {
return fInfo.width(); }
70 int height()
const {
return fInfo.height(); }
71 SkColorType colorType()
const {
return fInfo.colorType(); }
72 SkAlphaType alphaType()
const {
return fInfo.alphaType(); }
73 bool isOpaque()
const {
return fInfo.isOpaque(); }
75 SkIRect bounds()
const {
return SkIRect::MakeWH(this->width(), this->height()); }
88 uint64_t getSize64()
const {
return sk_64_mul(fInfo.height(), fRowBytes); }
89 uint64_t getSafeSize64()
const {
return fInfo.getSafeSize64(fRowBytes); }
90 size_t getSafeSize()
const {
return fInfo.getSafeSize(fRowBytes); }
92 const void* addr(
int x,
int y)
const {
93 return (
const char*)fPixels + fInfo.computeOffset(x, y, fRowBytes);
95 const uint8_t* addr8()
const {
96 SkASSERT(1 == SkColorTypeBytesPerPixel(fInfo.colorType()));
97 return reinterpret_cast<const uint8_t*
>(fPixels);
99 const uint16_t* addr16()
const {
100 SkASSERT(2 == SkColorTypeBytesPerPixel(fInfo.colorType()));
101 return reinterpret_cast<const uint16_t*
>(fPixels);
103 const uint32_t* addr32()
const {
104 SkASSERT(4 == SkColorTypeBytesPerPixel(fInfo.colorType()));
105 return reinterpret_cast<const uint32_t*
>(fPixels);
107 const uint64_t* addr64()
const {
108 SkASSERT(8 == SkColorTypeBytesPerPixel(fInfo.colorType()));
109 return reinterpret_cast<const uint64_t*
>(fPixels);
111 const uint16_t* addrF16()
const {
112 SkASSERT(8 == SkColorTypeBytesPerPixel(fInfo.colorType()));
113 SkASSERT(kRGBA_F16_SkColorType == fInfo.colorType());
114 return reinterpret_cast<const uint16_t*
>(fPixels);
119 const uint8_t* addr8(
int x,
int y)
const {
120 SkASSERT((
unsigned)x < (
unsigned)fInfo.width());
121 SkASSERT((
unsigned)y < (
unsigned)fInfo.height());
122 return (
const uint8_t*)((
const char*)this->addr8() + y * fRowBytes + (x << 0));
124 const uint16_t* addr16(
int x,
int y)
const {
125 SkASSERT((
unsigned)x < (
unsigned)fInfo.width());
126 SkASSERT((
unsigned)y < (
unsigned)fInfo.height());
127 return (
const uint16_t*)((
const char*)this->addr16() + y * fRowBytes + (x << 1));
129 const uint32_t* addr32(
int x,
int y)
const {
130 SkASSERT((
unsigned)x < (
unsigned)fInfo.width());
131 SkASSERT((
unsigned)y < (
unsigned)fInfo.height());
132 return (
const uint32_t*)((
const char*)this->addr32() + y * fRowBytes + (x << 2));
134 const uint64_t* addr64(
int x,
int y)
const {
135 SkASSERT((
unsigned)x < (
unsigned)fInfo.width());
136 SkASSERT((
unsigned)y < (
unsigned)fInfo.height());
137 return (
const uint64_t*)((
const char*)this->addr64() + y * fRowBytes + (x << 3));
139 const uint16_t* addrF16(
int x,
int y)
const {
140 SkASSERT(kRGBA_F16_SkColorType == fInfo.colorType());
141 return reinterpret_cast<const uint16_t*
>(this->addr64(x, y));
146 void* writable_addr()
const {
return const_cast<void*
>(fPixels); }
147 void* writable_addr(
int x,
int y)
const {
148 return const_cast<void*
>(this->addr(x, y));
150 uint8_t* writable_addr8(
int x,
int y)
const {
151 return const_cast<uint8_t*
>(this->addr8(x, y));
153 uint16_t* writable_addr16(
int x,
int y)
const {
154 return const_cast<uint16_t*
>(this->addr16(x, y));
156 uint32_t* writable_addr32(
int x,
int y)
const {
157 return const_cast<uint32_t*
>(this->addr32(x, y));
159 uint64_t* writable_addr64(
int x,
int y)
const {
160 return const_cast<uint64_t*
>(this->addr64(x, y));
162 uint16_t* writable_addrF16(
int x,
int y)
const {
163 return reinterpret_cast<uint16_t*
>(writable_addr64(x, y));
168 bool readPixels(
const SkImageInfo& dstInfo,
void* dstPixels,
size_t dstRowBytes,
169 int srcX,
int srcY)
const;
170 bool readPixels(
const SkImageInfo& dstInfo,
void* dstPixels,
size_t dstRowBytes)
const {
171 return this->readPixels(dstInfo, dstPixels, dstRowBytes, 0, 0);
173 bool readPixels(
const SkPixmap& dst,
int srcX,
int srcY)
const {
174 return this->readPixels(dst.info(), dst.writable_addr(), dst.rowBytes(), srcX, srcY);
176 bool readPixels(
const SkPixmap& dst)
const {
177 return this->readPixels(dst.info(), dst.writable_addr(), dst.rowBytes(), 0, 0);
187 bool scalePixels(
const SkPixmap& dst, SkFilterQuality)
const;
195 bool erase(
SkColor color)
const {
return this->erase(color, this->bounds()); }
213 : fUnlockProc(unlock), fUnlockContext(ctx), fPixmap(pm), fIsLocked(
true)
221 SkASSERT(this->isLocked());
225 bool isLocked()
const {
return fIsLocked; }
234 fUnlockProc(fUnlockContext);
244 void reset(
const SkPixmap& pm,
void (*unlock)(
void*),
void* ctx);
247 void (*fUnlockProc)(
void*);
248 void* fUnlockContext;
int rowBytesAsPixels() const
Return the rowbytes expressed as a number of pixels (like width and height).
Definition: SkPixmap.h:80
void unlock()
Unlocks the pixmap.
Definition: SkPixmap.h:231
Describe an image's dimensions and pixel type.
Definition: SkImageInfo.h:181
SkColorTable holds an array SkPMColors (premultiplied 32-bit colors) used by 8-bit bitmaps...
Definition: SkColorTable.h:25
Pairs SkImageInfo with actual pixels and rowbytes.
Definition: SkPixmap.h:23
Definition: SkColor.h:169
const SkPixmap & pixmap() const
Return the currently locked pixmap.
Definition: SkPixmap.h:220
SkMask is used to describe alpha bitmaps, either 1bit, 8bit, or the 3-channel 3D format.
Definition: SkMask.h:19
SkData holds an immutable data buffer.
Definition: SkData.h:22
The SkBitmap class specifies a raster bitmap.
Definition: SkBitmap.h:41
Definition: SkPixmap.h:209
uint32_t SkColor
32 bit ARGB color value, not premultiplied.
Definition: SkColor.h:28
SkIRect holds four 32 bit integer coordinates for a rectangle.
Definition: SkRect.h:20
int shiftPerPixel() const
Return the shift amount per pixel (i.e.
Definition: SkPixmap.h:86
Types and macros for colors.