cc309eb9b1
The latest, minor changes on includes already generated, plus four new ones. TBR=reed@google.com Bug: skia:6898 Change-Id: If06ae9b9aaa3a0a9fae570aa7a6698ff340c43b8 Reviewed-on: https://skia-review.googlesource.com/62862 Commit-Queue: Cary Clark <caryclark@skia.org> Reviewed-by: Cary Clark <caryclark@skia.org>
1321 lines
56 KiB
C++
1321 lines
56 KiB
C++
/*
|
|
* Copyright 2006 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 SkBitmap_DEFINED
|
|
#define SkBitmap_DEFINED
|
|
|
|
#include "SkColor.h"
|
|
#include "SkImageInfo.h"
|
|
#include "SkPixmap.h"
|
|
#include "SkPoint.h"
|
|
#include "SkRefCnt.h"
|
|
|
|
struct SkMask;
|
|
struct SkIRect;
|
|
struct SkRect;
|
|
class SkPaint;
|
|
class SkPixelRef;
|
|
class SkString;
|
|
|
|
/** \class SkBitmap
|
|
SkBitmap describes a two-dimensional raster pixel array. SkBitmap is built on
|
|
SkImageInfo, containing integer width and height, SkColorType and SkAlphaType
|
|
describing the pixel format, and SkColorSpace describing the range of colors.
|
|
SkBitmap points to SkPixelRef, which describes the physical array of pixels.
|
|
SkImageInfo bounds may be located anywhere fully inside SkPixelRef bounds.
|
|
|
|
SkBitmap can be drawn using SkCanvas. SkBitmap can be a drawing destination for SkCanvas
|
|
draw methods. SkBitmap flexibility as a pixel container limits some optimizations
|
|
available to the target platform.
|
|
|
|
If pixel array is primarily read-only, use SkImage for better performance.
|
|
If pixel array is primarily written to, use SkSurface for better performance.
|
|
|
|
Declaring SkBitmap const prevents altering SkImageInfo: the SkBitmap height, width,
|
|
and so on cannot change. It does not affect SkPixelRef: a caller may write its
|
|
pixels. Declaring SkBitmap const affects SkBitmap configuration, not its contents.
|
|
|
|
SkBitmap is not thread safe. Each thread must have its own copy of SkBitmap fields,
|
|
although threads may share the underlying pixel array.
|
|
*/
|
|
class SK_API SkBitmap {
|
|
public:
|
|
class SK_API Allocator;
|
|
|
|
/** Creates an empty SkBitmap without pixels, with kUnknown_SkColorType,
|
|
kUnknown_SkAlphaType, and with a width and height of zero. SkPixelRef origin is
|
|
set to (0, 0). SkBitmap is not volatile.
|
|
|
|
Use setInfo() to associate SkColorType, SkAlphaType, width, and height
|
|
after SkBitmap has been created.
|
|
|
|
@return empty SkBitmap
|
|
*/
|
|
SkBitmap();
|
|
|
|
/** Copies settings from src to returned SkBitmap. Shares pixels if src has pixels
|
|
allocated, so both bitmaps reference the same pixels.
|
|
|
|
@param src SkBitmap to copy SkImageInfo, and share SkPixelRef
|
|
@return copy of src
|
|
*/
|
|
SkBitmap(const SkBitmap& src);
|
|
|
|
/** Copies settings from src to returned SkBitmap. Moves ownership of src pixels to
|
|
SkBitmap.
|
|
|
|
@param src SkBitmap to copy SkImageInfo, and reassign SkPixelRef
|
|
@return copy of src
|
|
*/
|
|
SkBitmap(SkBitmap&& src);
|
|
|
|
/** Decrements SkPixelRef reference count, if SkPixelRef is not nullptr.
|
|
*/
|
|
~SkBitmap();
|
|
|
|
/** Copies settings from src to returned SkBitmap. Shares pixels if src has pixels
|
|
allocated, so both bitmaps reference the same pixels.
|
|
|
|
@param src SkBitmap to copy SkImageInfo, and share SkPixelRef
|
|
@return copy of src
|
|
*/
|
|
SkBitmap& operator=(const SkBitmap& src);
|
|
|
|
/** Copies settings from src to returned SkBitmap. Moves ownership of src pixels to
|
|
SkBitmap.
|
|
|
|
@param src SkBitmap to copy SkImageInfo, and reassign SkPixelRef
|
|
@return copy of src
|
|
*/
|
|
SkBitmap& operator=(SkBitmap&& src);
|
|
|
|
/** Swaps the fields of the two bitmaps.
|
|
|
|
@param other SkBitmap exchanged with original
|
|
*/
|
|
void swap(SkBitmap& other);
|
|
|
|
/** Returns width, height, SkAlphaType, SkColorType, and SkColorSpace.
|
|
|
|
@return reference to SkImageInfo
|
|
*/
|
|
const SkImageInfo& info() const { return fInfo; }
|
|
|
|
/** Returns pixel count in each pixel row. Should be equal or less than:
|
|
rowBytes() / info().bytesPerPixel().
|
|
|
|
Maybe be less than pixelRef().width(). Will not exceed pixelRef().width() less
|
|
pixelRefOrigin().fX.
|
|
|
|
@return pixel width in SkImageInfo
|
|
*/
|
|
int width() const { return fInfo.width(); }
|
|
|
|
/** Returns pixel row count.
|
|
|
|
Maybe be less than pixelRef().height(). Will not exceed pixelRef().height() less
|
|
pixelRefOrigin().fY.
|
|
|
|
@return pixel height in SkImageInfo
|
|
*/
|
|
int height() const { return fInfo.height(); }
|
|
|
|
/** Returns SkColorType, one of: kUnknown_SkColorType, kAlpha_8_SkColorType,
|
|
kRGB_565_SkColorType, kARGB_4444_SkColorType, kRGBA_8888_SkColorType,
|
|
kBGRA_8888_SkColorType, kGray_8_SkColorType, kRGBA_F16_SkColorType.
|
|
|
|
@return SkColorType in SkImageInfo
|
|
*/
|
|
SkColorType colorType() const { return fInfo.colorType(); }
|
|
|
|
/** Returns SkAlphaType, one of: kUnknown_SkAlphaType, kOpaque_SkAlphaType,
|
|
kPremul_SkAlphaType, kUnpremul_SkAlphaType.
|
|
|
|
@return SkAlphaType in SkImageInfo
|
|
*/
|
|
SkAlphaType alphaType() const { return fInfo.alphaType(); }
|
|
|
|
/** Returns SkColorSpace, the range of colors, associated with SkImageInfo. The
|
|
reference count of SkColorSpace is unchanged. The returned SkColorSpace is
|
|
immutable.
|
|
|
|
@return SkColorSpace in SkImageInfo
|
|
*/
|
|
SkColorSpace* colorSpace() const { return fInfo.colorSpace(); }
|
|
|
|
/** Returns a smart pointer to SkColorSpace, the range of colors, associated with
|
|
SkImageInfo. The smart pointer tracks the number of objects sharing this
|
|
SkColorSpace reference so the memory is released when the owners destruct.
|
|
|
|
The returned SkColorSpace is immutable.
|
|
|
|
@return SkColorSpace in SkImageInfo wrapped in a smart pointer
|
|
*/
|
|
sk_sp<SkColorSpace> refColorSpace() const { return fInfo.refColorSpace(); }
|
|
|
|
/** Returns number of bytes per pixel required by SkColorType.
|
|
Returns zero if colorType( is kUnknown_SkColorType.
|
|
|
|
@return bytes in pixel
|
|
*/
|
|
int bytesPerPixel() const { return fInfo.bytesPerPixel(); }
|
|
|
|
/** Returns number of pixels that fit on row. Should be greater than or equal to
|
|
width().
|
|
|
|
@return maximum pixels per row
|
|
*/
|
|
int rowBytesAsPixels() const {
|
|
return fRowBytes >> this->shiftPerPixel();
|
|
}
|
|
|
|
/** Returns bit shift converting row bytes to row pixels.
|
|
Returns zero for kUnknown_SkColorType.
|
|
|
|
@return one of: 0, 1, 2, 3; left shift to convert pixels to bytes
|
|
*/
|
|
int shiftPerPixel() const { return this->fInfo.shiftPerPixel(); }
|
|
|
|
/** Returns true if either width() or height() are zero.
|
|
|
|
Does not check if SkPixelRef is nullptr; call drawsNothing() to check width(),
|
|
height(), and SkPixelRef.
|
|
|
|
@return true if dimensions do not enclose area
|
|
*/
|
|
bool empty() const { return fInfo.isEmpty(); }
|
|
|
|
/** Return true if SkPixelRef is nullptr.
|
|
|
|
Does not check if width() or height() are zero; call drawsNothing() to check
|
|
width(), height(), and SkPixelRef.
|
|
|
|
@return true if no SkPixelRef is associated
|
|
*/
|
|
bool isNull() const { return nullptr == fPixelRef; }
|
|
|
|
/** Return true if width() or height() are zero, or if SkPixelRef is nullptr.
|
|
If true, SkBitmap has no effect when drawn or drawn into.
|
|
|
|
@return true if drawing has no effect
|
|
*/
|
|
bool drawsNothing() const {
|
|
return this->empty() || this->isNull();
|
|
}
|
|
|
|
/** Returns row bytes, the interval from one pixel row to the next. Row bytes
|
|
is at least as large as width() * info().bytesPerPixel().
|
|
|
|
Returns zero if colorType() is kUnknown_SkColorType, or if row bytes supplied to
|
|
setInfo() is not large enough to hold a row of pixels.
|
|
|
|
@return byte length of pixel row
|
|
*/
|
|
size_t rowBytes() const { return fRowBytes; }
|
|
|
|
/** Sets SkAlphaType, if alphaType is compatible with SkColorType.
|
|
Returns true unless alphaType is kUnknown_SkAlphaType and current SkAlphaType
|
|
is not kUnknown_SkAlphaType.
|
|
|
|
Returns true if SkColorType is kUnknown_SkColorType. alphaType is ignored, and
|
|
SkAlphaType remains kUnknown_SkAlphaType.
|
|
|
|
Returns true if SkColorType is kRGB_565_SkColorType or kGray_8_SkColorType.
|
|
alphaType is ignored, and SkAlphaType remains kOpaque_SkAlphaType.
|
|
|
|
If SkColorType is kARGB_4444_SkColorType, kRGBA_8888_SkColorType,
|
|
kBGRA_8888_SkColorType, or kRGBA_F16_SkColorType: returns true unless
|
|
alphaType is kUnknown_SkAlphaType and SkAlphaType is not kUnknown_SkAlphaType.
|
|
If SkAlphaType is kUnknown_SkAlphaType, alphaType is ignored.
|
|
|
|
If SkColorType is kAlpha_8_SkColorType, returns true unless
|
|
alphaType is kUnknown_SkAlphaType and SkAlphaType is not kUnknown_SkAlphaType.
|
|
If SkAlphaType is kUnknown_SkAlphaType, alphaType is ignored. If alphaType is
|
|
kUnpremul_SkAlphaType, it is treated as kPremul_SkAlphaType.
|
|
|
|
This changes SkAlphaType in SkPixelRef; all bitmaps sharing SkPixelRef
|
|
are affected.
|
|
|
|
@param alphaType one of: kUnknown_SkAlphaType, kOpaque_SkAlphaType,
|
|
kPremul_SkAlphaType, kUnpremul_SkAlphaType
|
|
@return true if SkAlphaType is set
|
|
*/
|
|
bool setAlphaType(SkAlphaType alphaType);
|
|
|
|
/** Returns pixel address, the base address corresponding to the pixel origin.
|
|
|
|
@return pixel address
|
|
*/
|
|
void* getPixels() const { return fPixels; }
|
|
|
|
/** Returns minimum memory required for pixel storage.
|
|
Does not include unused memory on last row when rowBytesAsPixels() exceeds width().
|
|
Returns zero if result does not fit in size_t.
|
|
Returns zero if height() or width() is 0.
|
|
Returns height() times rowBytes() if colorType() is kUnknown_SkColorType.
|
|
|
|
@return size in bytes of image buffer
|
|
*/
|
|
size_t computeByteSize() const { return fInfo.computeByteSize(fRowBytes); }
|
|
|
|
/** Returns true if pixels can not change.
|
|
|
|
Most immutable SkBitmap checks trigger an assert only on debug builds.
|
|
|
|
@return true if pixels are immutable
|
|
*/
|
|
bool isImmutable() const;
|
|
|
|
/** Sets internal flag to mark SkBitmap as immutable. Once set, pixels can not change.
|
|
Any other bitmap sharing the same SkPixelRef are also marked as immutable.
|
|
Once SkPixelRef is marked immutable, the setting cannot be cleared.
|
|
|
|
Writing to immutable SkBitmap pixels triggers an assert on debug builds.
|
|
*/
|
|
void setImmutable();
|
|
|
|
/** Returns true if SkAlphaType is kOpaque_SkAlphaType.
|
|
Does not check if SkColorType allows alpha, or if any pixel value has
|
|
transparency.
|
|
|
|
@return true if SkImageInfo describes opaque alpha
|
|
*/
|
|
bool isOpaque() const {
|
|
return SkAlphaTypeIsOpaque(this->alphaType());
|
|
}
|
|
|
|
/** If true, provides a hint to caller that pixels should not
|
|
be cached. Only true if setIsVolatile() has been called to mark as volatile.
|
|
|
|
Volatile state is not shared by other bitmaps sharing the same SkPixelRef.
|
|
|
|
@return true if marked volatile
|
|
*/
|
|
bool isVolatile() const;
|
|
|
|
/** Sets if pixels should be read from SkPixelRef on every access. SkBitmap are not
|
|
volatile by default; a GPU back end may upload pixel values expecting them to be
|
|
accessed repeatedly. Marking temporary SkBitmap as volatile provides a hint to
|
|
SkBaseDevice that the SkBitmap pixels should not be cached. This can
|
|
improve performance by avoiding overhead and reducing resource
|
|
consumption on SkBaseDevice.
|
|
|
|
@param isVolatile true if backing pixels are temporary
|
|
*/
|
|
void setIsVolatile(bool isVolatile);
|
|
|
|
/** Resets to its initial state; all fields are set to zero, as if SkBitmap had
|
|
been initialized by SkBitmap().
|
|
|
|
Sets width, height, row bytes to zero; pixel address to nullptr; SkColorType to
|
|
kUnknown_SkColorType; and SkAlphaType to kUnknown_SkAlphaType.
|
|
|
|
If SkPixelRef is allocated, its reference count is decreased by one, releasing
|
|
its memory if SkBitmap is the sole owner.
|
|
*/
|
|
void reset();
|
|
|
|
/** Returns true if all pixels are opaque. SkColorType determines how pixels
|
|
are encoded, and whether pixel describes alpha. Returns true for SkColorType
|
|
without alpha in each pixel; for other SkColorType, returns true if all
|
|
pixels have alpha values equivalent to 1.0 or greater.
|
|
|
|
For SkColorType kRGB_565_SkColorType or kGray_8_SkColorType: always
|
|
returns true. For SkColorType kAlpha_8_SkColorType, kBGRA_8888_SkColorType,
|
|
kRGBA_8888_SkColorType: returns true if all pixel alpha values are 255.
|
|
For SkColorType kARGB_4444_SkColorType: returns true if all pixel alpha values are 15.
|
|
For kRGBA_F16_SkColorType: returns true if all pixel alpha values are 1.0 or
|
|
greater.
|
|
|
|
Returns false for kUnknown_SkColorType.
|
|
|
|
@param bm SkBitmap to check
|
|
@return true if all pixels have opaque values or SkColorType is opaque
|
|
*/
|
|
static bool ComputeIsOpaque(const SkBitmap& bm) {
|
|
SkPixmap pmap;
|
|
return bm.peekPixels(&pmap) && pmap.computeIsOpaque();
|
|
}
|
|
|
|
/** Returns SkRect { 0, 0, width(), height() }.
|
|
|
|
@param bounds container for floating point rectangle
|
|
*/
|
|
void getBounds(SkRect* bounds) const;
|
|
|
|
/** Returns SkIRect { 0, 0, width(), height() }.
|
|
|
|
@param bounds container for integral rectangle
|
|
*/
|
|
void getBounds(SkIRect* bounds) const;
|
|
|
|
/** Returns SkIRect { 0, 0, width(), height() }.
|
|
|
|
@return integral rectangle from origin to width() and height()
|
|
*/
|
|
SkIRect bounds() const { return fInfo.bounds(); }
|
|
|
|
/** Returns SkISize { width(), height() }.
|
|
|
|
@return integral size of width() and height()
|
|
*/
|
|
SkISize dimensions() const { return fInfo.dimensions(); }
|
|
|
|
/** Returns the bounds of this bitmap, offset by its SkPixelRef origin.
|
|
|
|
@return bounds within SkPixelRef bounds
|
|
*/
|
|
SkIRect getSubset() const {
|
|
return SkIRect::MakeXYWH(fPixelRefOrigin.x(), fPixelRefOrigin.y(),
|
|
fInfo.width(), fInfo.height());
|
|
}
|
|
|
|
/** Sets width, height, SkAlphaType, SkColorType, SkColorSpace, and optional
|
|
rowBytes. Frees pixels, and returns true if successful.
|
|
|
|
imageInfo.alphaType() may be altered to a value permitted by imageInfo.colorSpace().
|
|
If imageInfo.colorType() is kUnknown_SkColorType, imageInfo.alphaType() is
|
|
set to kUnknown_SkAlphaType.
|
|
If imageInfo.colorType() is kAlpha_8_SkColorType and imageInfo.alphaType() is
|
|
kUnpremul_SkAlphaType, imageInfo.alphaType() is replaced by kPremul_SkAlphaType.
|
|
If imageInfo.colorType() is kRGB_565_SkColorType or kGray_8_SkColorType,
|
|
imageInfo.alphaType() is set to kOpaque_SkAlphaType.
|
|
If imageInfo.colorType() is kARGB_4444_SkColorType, kRGBA_8888_SkColorType,
|
|
kBGRA_8888_SkColorType, or kRGBA_F16_SkColorType: imageInfo.alphaType() remains
|
|
unchanged.
|
|
|
|
rowBytes must equal or exceed imageInfo.minRowBytes(). If imageInfo.colorSpace() is
|
|
kUnknown_SkColorType, rowBytes is ignored and treated as zero; for all other
|
|
SkColorSpace values, rowBytes of zero is treated as imageInfo.minRowBytes().
|
|
|
|
Calls reset() and returns false if:
|
|
- rowBytes exceeds 31 bits
|
|
- imageInfo.width() times imageInfo.bytesPerPixel() exceeds 31 bits
|
|
- imageInfo.width() is negative
|
|
- imageInfo.height() is negative
|
|
- rowBytes is positive and less than imageInfo.width() times imageInfo.bytesPerPixel()
|
|
|
|
@param imageInfo contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@param rowBytes imageInfo.minRowBytes or larger; or zero
|
|
@return true if SkImageInfo set successfully
|
|
*/
|
|
bool setInfo(const SkImageInfo& imageInfo, size_t rowBytes = 0);
|
|
|
|
/** \enum SkBitmap::AllocFlags
|
|
AllocFlags provides the option to zero pixel memory when allocated.
|
|
*/
|
|
enum AllocFlags {
|
|
/** Instructs tryAllocPixelsFlags() and allocPixelsFlags() to zero pixel memory. */
|
|
kZeroPixels_AllocFlag = 1 << 0,
|
|
};
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo() and allocates pixel
|
|
memory. If flags is kZeroPixels_AllocFlag, memory is zeroed.
|
|
|
|
Returns false and calls reset() if SkImageInfo could not be set, or memory could
|
|
not be allocated, or memory size exceeds 31 bits, or memory could not optionally
|
|
be zeroed.
|
|
|
|
On most platforms, allocating pixel memory may succeed even though there is
|
|
not sufficient memory to hold pixels; allocation does not take place
|
|
until the pixels are written to. The actual behavior depends on the platform
|
|
implementation of malloc(), if flags is zero, and calloc(), if flags is
|
|
kZeroPixels_AllocFlag.
|
|
|
|
Passing kZeroPixels_AllocFlag is usually faster than separately calling
|
|
eraseColor(SK_ColorTRANSPARENT).
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@param flags kZeroPixels_AllocFlag, or zero
|
|
@return true if pixels allocation is successful
|
|
*/
|
|
bool SK_WARN_UNUSED_RESULT tryAllocPixelsFlags(const SkImageInfo& info, uint32_t flags);
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo() and allocates pixel
|
|
memory. If flags is kZeroPixels_AllocFlag, memory is zeroed.
|
|
|
|
Aborts execution if SkImageInfo could not be set, or memory could
|
|
not be allocated, or memory size exceeds 31 bits, or memory could not optionally
|
|
be zeroed. Abort steps may be provided by the user at compile time by defining
|
|
SK_ABORT.
|
|
|
|
On most platforms, allocating pixel memory may succeed even though there is
|
|
not sufficient memory to hold pixels; allocation does not take place
|
|
until the pixels are written to. The actual behavior depends on the platform
|
|
implementation of malloc(), if flags is zero, and calloc(), if flags is
|
|
kZeroPixels_AllocFlag.
|
|
|
|
Passing kZeroPixels_AllocFlag is usually faster than separately calling
|
|
eraseColor(SK_ColorTRANSPARENT).
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@param flags kZeroPixels_AllocFlag, or zero
|
|
*/
|
|
void allocPixelsFlags(const SkImageInfo& info, uint32_t flags) {
|
|
SkASSERT_RELEASE(this->tryAllocPixelsFlags(info, flags));
|
|
}
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo() and allocates pixel
|
|
memory. rowBytes must equal or exceed info.width() times info.bytesPerPixel(),
|
|
or equal zero. Pass in zero for rowBytes to compute the minimum valid value.
|
|
|
|
Returns false and calls reset() if SkImageInfo could not be set, or memory could
|
|
not be allocated.
|
|
|
|
On most platforms, allocating pixel memory may succeed even though there is
|
|
not sufficient memory to hold pixels; allocation does not take place
|
|
until the pixels are written to. The actual behavior depends on the platform
|
|
implementation of malloc().
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@param rowBytes size of pixel row or larger; may be zero
|
|
@return true if pixel storage is allocated
|
|
*/
|
|
bool SK_WARN_UNUSED_RESULT tryAllocPixels(const SkImageInfo& info, size_t rowBytes);
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo() and allocates pixel
|
|
memory. rowBytes must equal or exceed info.width() times info.bytesPerPixel(),
|
|
or equal zero. Pass in zero for rowBytes to compute the minimum valid value.
|
|
|
|
Aborts execution if SkImageInfo could not be set, or memory could
|
|
not be allocated, or memory size exceeds 31 bits. Abort steps may be provided by
|
|
the user at compile time by defining SK_ABORT.
|
|
|
|
On most platforms, allocating pixel memory may succeed even though there is
|
|
not sufficient memory to hold pixels; allocation does not take place
|
|
until the pixels are written to. The actual behavior depends on the platform
|
|
implementation of malloc().
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@param rowBytes size of pixel row or larger; may be zero
|
|
*/
|
|
void allocPixels(const SkImageInfo& info, size_t rowBytes) {
|
|
SkASSERT_RELEASE(this->tryAllocPixels(info, rowBytes));
|
|
}
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo() and allocates pixel
|
|
memory.
|
|
|
|
Returns false and calls reset() if SkImageInfo could not be set, or memory could
|
|
not be allocated.
|
|
|
|
On most platforms, allocating pixel memory may succeed even though there is
|
|
not sufficient memory to hold pixels; allocation does not take place
|
|
until the pixels are written to. The actual behavior depends on the platform
|
|
implementation of malloc().
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@return true if pixel storage is allocated
|
|
*/
|
|
bool SK_WARN_UNUSED_RESULT tryAllocPixels(const SkImageInfo& info) {
|
|
return this->tryAllocPixels(info, info.minRowBytes());
|
|
}
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo() and allocates pixel
|
|
memory.
|
|
|
|
Aborts execution if SkImageInfo could not be set, or memory could
|
|
not be allocated, or memory size exceeds 31 bits. Abort steps may be provided by
|
|
the user at compile time by defining SK_ABORT.
|
|
|
|
On most platforms, allocating pixel memory may succeed even though there is
|
|
not sufficient memory to hold pixels; allocation does not take place
|
|
until the pixels are written to. The actual behavior depends on the platform
|
|
implementation of malloc().
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
*/
|
|
void allocPixels(const SkImageInfo& info) {
|
|
this->allocPixels(info, info.minRowBytes());
|
|
}
|
|
|
|
/** Sets SkImageInfo to width, height, and the native SkColorType; and allocates
|
|
pixel memory. If isOpaque is true, sets SkImageInfo to kOpaque_SkAlphaType;
|
|
otherwise, sets to kPremul_SkAlphaType.
|
|
|
|
Calls reset() and returns false if width exceeds 29 bits or is negative,
|
|
or height is negative.
|
|
|
|
Returns false if allocation fails.
|
|
|
|
Use to create SkBitmap that matches native pixel arrangement on the platform,
|
|
to draw without converting its pixel format.
|
|
|
|
@param width pixel column count; must be zero or greater
|
|
@param height pixel row count; must be zero or greater
|
|
@param isOpaque true if pixels do not have transparency
|
|
@return true if pixel storage is allocated
|
|
*/
|
|
bool SK_WARN_UNUSED_RESULT tryAllocN32Pixels(int width, int height, bool isOpaque = false) {
|
|
SkImageInfo info = SkImageInfo::MakeN32(width, height,
|
|
isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
|
|
return this->tryAllocPixels(info);
|
|
}
|
|
|
|
/** Sets SkImageInfo to width, height, and the native SkColorType; and allocates
|
|
pixel memory. If isOpaque is true, sets SkImageInfo to kPremul_SkAlphaType;
|
|
otherwise, sets to kOpaque_SkAlphaType.
|
|
|
|
Aborts if width exceeds 29 bits or is negative, or height is negative, or
|
|
allocation fails. Abort steps may be provided by the user at compile time by
|
|
defining SK_ABORT.
|
|
|
|
Use to create SkBitmap that matches native pixel arrangement on the platform,
|
|
to draw without converting its pixel format.
|
|
|
|
@param width pixel column count; must be zero or greater
|
|
@param height pixel row count; must be zero or greater
|
|
@param isOpaque true if pixels do not have transparency
|
|
*/
|
|
void allocN32Pixels(int width, int height, bool isOpaque = false) {
|
|
SkImageInfo info = SkImageInfo::MakeN32(width, height,
|
|
isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
|
|
this->allocPixels(info);
|
|
}
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo(), and creates SkPixelRef
|
|
containing pixels and rowBytes. releaseProc, if not nullptr, is called
|
|
immediately on failure or when pixels are no longer referenced. context may be
|
|
nullptr.
|
|
|
|
If SkImageInfo could not be set, or rowBytes is less than info.minRowBytes():
|
|
calls releaseProc if present, calls reset(), and returns false.
|
|
|
|
Otherwise, if pixels equals nullptr: sets SkImageInfo, calls releaseProc if
|
|
present, returns true.
|
|
|
|
If SkImageInfo is set, pixels is not nullptr, and releaseProc is not nullptr:
|
|
when pixels are no longer referenced, calls releaseProc with pixels and context
|
|
as parameters.
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@param pixels address or pixel storage; may be nullptr
|
|
@param rowBytes size of pixel row or larger
|
|
@param releaseProc function called when pixels can be deleted; may be nullptr
|
|
@param context caller state passed to releaseProc; may be nullptr
|
|
@return true if SkImageInfo is set to info
|
|
*/
|
|
bool installPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
|
|
void (*releaseProc)(void* addr, void* context), void* context);
|
|
|
|
/** Sets SkImageInfo to info following the rules in setInfo(), and creates SkPixelRef
|
|
containing pixels and rowBytes.
|
|
|
|
If SkImageInfo could not be set, or rowBytes is less than info.minRowBytes():
|
|
calls reset(), and returns false.
|
|
|
|
Otherwise, if pixels equals nullptr: sets SkImageInfo, returns true.
|
|
|
|
Caller must ensure that pixels are valid for the lifetime of SkBitmap and SkPixelRef.
|
|
|
|
@param info contains width, height, SkAlphaType, SkColorType, SkColorSpace
|
|
@param pixels address or pixel storage; may be nullptr
|
|
@param rowBytes size of pixel row or larger
|
|
@return true if SkImageInfo is set to info
|
|
*/
|
|
bool installPixels(const SkImageInfo& info, void* pixels, size_t rowBytes) {
|
|
return this->installPixels(info, pixels, rowBytes, nullptr, nullptr);
|
|
}
|
|
|
|
/** Sets SkImageInfo to pixmap.info() following the rules in setInfo(), and creates
|
|
SkPixelRef containing pixmap.addr() and pixmap.rowBytes().
|
|
|
|
If SkImageInfo could not be set, or pixmap.rowBytes() is less than
|
|
SkImageInfo::minRowBytes: calls reset(), and returns false.
|
|
|
|
Otherwise, if pixmap.addr() equals nullptr: sets SkImageInfo, returns true.
|
|
|
|
Caller must ensure that pixmap is valid for the lifetime of SkBitmap and SkPixelRef.
|
|
|
|
@param pixmap SkImageInfo, pixel address, and rowBytes()
|
|
@return true if SkImageInfo was set to pixmap.info()
|
|
*/
|
|
bool installPixels(const SkPixmap& pixmap);
|
|
|
|
/** Sets SkImageInfo to mask width, mask height, kAlpha_8_SkColorType, and
|
|
kPremul_SkAlphaType. Sets SkPixelRef to mask image and mask rowBytes().
|
|
|
|
Returns false and calls reset() if mask format is not SkMask::kA8_Format,
|
|
or if mask width or mask height is negative, or if mask rowBytes() is less
|
|
than mask width.
|
|
|
|
Caller must ensure that mask is valid for the lifetime of SkBitmap and SkPixelRef.
|
|
|
|
@param mask alpha 8-bit bitmap
|
|
@return true if SkImageInfo and SkPixelRef refer to mask
|
|
*/
|
|
bool installMaskPixels(const SkMask& mask);
|
|
|
|
/** Replaces SkPixelRef with pixels, preserving SkImageInfo and rowBytes().
|
|
Sets SkPixelRef origin to (0, 0).
|
|
|
|
If pixels is nullptr, or if info().colorType equals kUnknown_SkColorType;
|
|
release reference to SkPixelRef, and set SkPixelRef to nullptr.
|
|
|
|
Caller is responsible for handling ownership pixel memory for the lifetime
|
|
of SkBitmap and SkPixelRef.
|
|
|
|
@param pixels address of pixel storage, managed by caller
|
|
*/
|
|
void setPixels(void* pixels);
|
|
|
|
/** Allocates pixel memory with HeapAllocator, and replaces existing SkPixelRef.
|
|
The allocation size is determined by SkImageInfo width, height, and SkColorType.
|
|
|
|
Returns false if info().colorType is kUnknown_SkColorType, or allocation exceeds
|
|
31 bits, or allocation fails.
|
|
|
|
@return true if the allocation succeeds
|
|
*/
|
|
bool SK_WARN_UNUSED_RESULT tryAllocPixels() {
|
|
return this->tryAllocPixels((Allocator*)nullptr);
|
|
}
|
|
|
|
/** Allocates pixel memory with HeapAllocator, and replaces existing SkPixelRef.
|
|
The allocation size is determined by SkImageInfo width, height, and SkColorType.
|
|
|
|
Aborts if info().colorType is kUnknown_SkColorType, or allocation exceeds
|
|
31 bits, or allocation fails. Abort steps may be provided by the user at compile
|
|
time by defining SK_ABORT.
|
|
*/
|
|
void allocPixels() {
|
|
this->allocPixels((Allocator*)nullptr);
|
|
}
|
|
|
|
/** Allocates pixel memory with allocator, and replaces existing SkPixelRef.
|
|
The allocation size is determined by SkImageInfo width, height, and SkColorType.
|
|
If allocator is nullptr, use HeapAllocator instead.
|
|
|
|
Returns false if allocator allocPixelRef return false.
|
|
|
|
@param allocator instance of SkBitmap::Allocator instantiation
|
|
@return true if custom allocator reports success
|
|
*/
|
|
bool SK_WARN_UNUSED_RESULT tryAllocPixels(Allocator* allocator);
|
|
|
|
/** Allocates pixel memory with allocator, and replaces existing SkPixelRef.
|
|
The allocation size is determined by SkImageInfo width, height, and SkColorType.
|
|
If allocator is nullptr, use HeapAllocator instead.
|
|
|
|
Aborts if allocator allocPixelRef return false. Abort steps may be provided by
|
|
the user at compile time by defining SK_ABORT.
|
|
|
|
@param allocator instance of SkBitmap::Allocator instantiation
|
|
*/
|
|
void allocPixels(Allocator* allocator) {
|
|
SkASSERT_RELEASE(this->tryAllocPixels(allocator));
|
|
}
|
|
|
|
/** Returns SkPixelRef, which contains: pixel base address; its dimensions; and
|
|
rowBytes(), the interval from one row to the next. Does not change SkPixelRef
|
|
reference count. SkPixelRef may be shared by multiple bitmaps.
|
|
If SkPixelRef has not been set, returns nullptr.
|
|
|
|
@return SkPixelRef, or nullptr
|
|
*/
|
|
SkPixelRef* pixelRef() const { return fPixelRef.get(); }
|
|
|
|
/** Returns origin of pixels within SkPixelRef. SkBitmap bounds is always contained
|
|
by SkPixelRef bounds, which may be the same size or larger. Multiple SkBitmap
|
|
can share the same SkPixelRef, where each SkBitmap has different bounds.
|
|
|
|
The returned origin added to SkBitmap dimensions equals or is smaller than the
|
|
SkPixelRef dimensions.
|
|
|
|
Returns (0, 0) if SkPixelRef is nullptr.
|
|
|
|
@return pixel origin within SkPixelRef
|
|
*/
|
|
SkIPoint pixelRefOrigin() const { return fPixelRefOrigin; }
|
|
|
|
/** Replaces pixelRef and origin in SkBitmap. dx and dy specify the offset
|
|
within the SkPixelRef pixels for the top-left corner of the bitmap.
|
|
|
|
Asserts in debug builds if dx or dy are out of range. Pins dx and dy
|
|
to legal range in release builds.
|
|
|
|
The caller is responsible for ensuring that the pixels match the
|
|
SkColorType and SkAlphaType in SkImageInfo.
|
|
|
|
@param pixelRef SkPixelRef describing pixel address and rowBytes()
|
|
@param dx column offset in SkPixelRef for bitmap origin
|
|
@param dy row offset in SkPixelRef for bitmap origin
|
|
*/
|
|
void setPixelRef(sk_sp<SkPixelRef> pixelRef, int dx, int dy);
|
|
|
|
/** Returns true if SkBitmap is can be drawn.
|
|
|
|
@return true if getPixels() is not nullptr
|
|
*/
|
|
bool readyToDraw() const {
|
|
return this->getPixels() != nullptr;
|
|
}
|
|
|
|
/** Returns a unique value corresponding to the pixels in SkPixelRef.
|
|
Returns a different value after notifyPixelsChanged() has been called.
|
|
Returns zero if SkPixelRef is nullptr.
|
|
|
|
Determines if pixels have changed since last examined.
|
|
|
|
@return unique value for pixels in SkPixelRef
|
|
*/
|
|
uint32_t getGenerationID() const;
|
|
|
|
/** Marks that pixels in SkPixelRef have changed. Subsequent calls to
|
|
getGenerationID() return a different value.
|
|
*/
|
|
void notifyPixelsChanged() const;
|
|
|
|
/** Replaces pixel values with c. All pixels contained by bounds() are affected.
|
|
If the colorType() is kGray_8_SkColorType or k565_SkColorType, then color alpha
|
|
is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType,
|
|
then RGB is ignored.
|
|
|
|
@param c unpremultiplied color
|
|
*/
|
|
void eraseColor(SkColor c) const;
|
|
|
|
/** Replaces pixel values with unpremultiplied color built from a, r, g, and b.
|
|
All pixels contained by bounds() are affected.
|
|
If the colorType() is kGray_8_SkColorType or k565_SkColorType, then a
|
|
is ignored; r, g, and b are treated as opaque. If colorType() is kAlpha_8_SkColorType,
|
|
then r, g, and b are ignored.
|
|
|
|
@param a amount of color alpha, from fully transparent (0) to fully opaque (255)
|
|
@param r amount of color rgb red, from no red (0) to full red (255)
|
|
@param g amount of color rgb green, from no green (0) to full green (255)
|
|
@param b amount of color rgb blue, from no blue (0) to full blue (255)
|
|
*/
|
|
void eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
|
|
this->eraseColor(SkColorSetARGB(a, r, g, b));
|
|
}
|
|
|
|
/** Deprecated. Use eraseARGB() or eraseColor().
|
|
|
|
@param r amount of red
|
|
@param g amount of green
|
|
@param b amount of blue
|
|
*/
|
|
SK_ATTR_DEPRECATED("use eraseARGB or eraseColor")
|
|
void eraseRGB(U8CPU r, U8CPU g, U8CPU b) const {
|
|
this->eraseARGB(0xFF, r, g, b);
|
|
}
|
|
|
|
/** Replaces pixel values inside area with c. If area does not intersect bounds(),
|
|
call has no effect.
|
|
|
|
If the colorType() is kGray_8_SkColorType or k565_SkColorType, then color alpha
|
|
is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType,
|
|
then RGB is ignored.
|
|
|
|
@param c unpremultiplied color
|
|
@param area rectangle to fill
|
|
*/
|
|
void erase(SkColor c, const SkIRect& area) const;
|
|
|
|
/** Legacy call to be deprecated.
|
|
*/
|
|
void eraseArea(const SkIRect& area, SkColor c) const {
|
|
this->erase(c, area);
|
|
}
|
|
|
|
/** Returns pixel at (x, y) as unpremultiplied color.
|
|
Returns black with alpha if SkColorType is kAlpha_8_SkColorType.
|
|
|
|
Input is not validated: out of bounds values of x or y trigger an assert() if
|
|
built with SK_DEBUG defined; and returns undefined values or may crash if
|
|
SK_RELEASE is defined. Fails if SkColorType is kUnknown_SkColorType or
|
|
pixel address is nullptr.
|
|
|
|
SkColorSpace in SkImageInfo is ignored. Some color precision may be lost in the
|
|
conversion to unpremultiplied color; original pixel data may have additional
|
|
precision.
|
|
|
|
@param x column index, zero or greater, and less than width()
|
|
@param y row index, zero or greater, and less than height()
|
|
@return pixel converted to unpremultiplied color
|
|
*/
|
|
SkColor getColor(int x, int y) const {
|
|
SkPixmap pixmap;
|
|
SkAssertResult(this->peekPixels(&pixmap));
|
|
return pixmap.getColor(x, y);
|
|
}
|
|
|
|
/** Returns pixel address at (x, y).
|
|
|
|
Input is not validated: out of bounds values of x or y, or kUnknown_SkColorType,
|
|
trigger an assert() if built with SK_DEBUG defined. Returns nullptr if
|
|
SkColorType is kUnknown_SkColorType, or SkPixelRef is nullptr.
|
|
|
|
Performs a lookup of pixel size; for better performance, call
|
|
one of: getAddr8(), getAddr16(), or getAddr32().
|
|
|
|
@param x column index, zero or greater, and less than width()
|
|
@param y row index, zero or greater, and less than height()
|
|
@return generic pointer to pixel
|
|
*/
|
|
void* getAddr(int x, int y) const;
|
|
|
|
/** Returns address at (x, y).
|
|
|
|
Input is not validated. Triggers an assert() if built with SK_DEBUG defined and:
|
|
- SkPixelRef is nullptr
|
|
- bytesPerPixel() is not four
|
|
- x is negative, or not less than width()
|
|
- y is negative, or not less than height()
|
|
|
|
@param x column index, zero or greater, and less than width()
|
|
@param y row index, zero or greater, and less than height()
|
|
@return unsigned 32-bit pointer to pixel at (x, y)
|
|
*/
|
|
inline uint32_t* getAddr32(int x, int y) const;
|
|
|
|
/** Returns address at (x, y).
|
|
|
|
Input is not validated. Triggers an assert() if built with SK_DEBUG defined and:
|
|
- SkPixelRef is nullptr
|
|
- bytesPerPixel() is not two
|
|
- x is negative, or not less than width()
|
|
- y is negative, or not less than height()
|
|
|
|
@param x column index, zero or greater, and less than width()
|
|
@param y row index, zero or greater, and less than height()
|
|
@return unsigned 16-bit pointer to pixel at (x, y)
|
|
*/
|
|
inline uint16_t* getAddr16(int x, int y) const;
|
|
|
|
/** Returns address at (x, y).
|
|
|
|
Input is not validated. Triggers an assert() if built with SK_DEBUG defined and:
|
|
- SkPixelRef is nullptr
|
|
- bytesPerPixel() is not one
|
|
- x is negative, or not less than width()
|
|
- y is negative, or not less than height()
|
|
|
|
@param x column index, zero or greater, and less than width()
|
|
@param y row index, zero or greater, and less than height()
|
|
@return unsigned 8-bit pointer to pixel at (x, y)
|
|
*/
|
|
inline uint8_t* getAddr8(int x, int y) const;
|
|
|
|
/** Shares SkPixelRef with dst. Pixels are not copied; SkBitmap and dst point
|
|
to the same pixels; dst bounds() are set to the intersection of subset
|
|
and the original bounds().
|
|
|
|
subset may be larger than bounds(). Any area outside of bounds() is ignored.
|
|
|
|
Any contents of dst are discarded. isVolatile() setting is copied to dst.
|
|
dst is set to colorType(), alphaType(), and colorSpace().
|
|
|
|
Return false if:
|
|
- dst is nullptr
|
|
- SkPixelRef is nullptr
|
|
- subset does not intersect bounds()
|
|
|
|
@param dst SkBitmap set to subset
|
|
@param subset rectangle of pixels to reference
|
|
@return true if dst is replaced by subset
|
|
*/
|
|
bool extractSubset(SkBitmap* dst, const SkIRect& subset) const;
|
|
|
|
/** Copies a SkRect of pixels to dstPixels. Copy starts at (srcX, srcY), and does not exceed
|
|
(this->width(), this->height()).
|
|
|
|
dstInfo specifies width, height, SkColorType, SkAlphaType, and
|
|
SkColorSpace of destination. dstRowBytes specifics the gap from one destination
|
|
row to the next. Returns true if pixels are copied. Returns false if:
|
|
- dstInfo.addr() equals nullptr
|
|
- dstRowBytes is less than dstInfo.minRowBytes()
|
|
- SkPixelRef is nullptr
|
|
|
|
Pixels are copied only if pixel conversion is possible. If this->colorType() is
|
|
kGray_8_SkColorType, or kAlpha_8_SkColorType; dstInfo.colorType() must match.
|
|
If this->colorType() is kGray_8_SkColorType, dstInfo.colorSpace() must match.
|
|
If this->alphaType() is kOpaque_SkAlphaType, dstInfo.alphaType() must
|
|
match. If this->colorSpace() is nullptr, dstInfo.colorSpace() must match. Returns
|
|
false if pixel conversion is not possible.
|
|
|
|
srcX and srcY may be negative to copy only top or left of source. Returns
|
|
false if width() or height() is zero or negative.
|
|
Returns false if abs(srcX) >= this->width(), or if abs(srcY) >= this->height().
|
|
|
|
If behavior is SkTransferFunctionBehavior::kRespect: converts source
|
|
pixels to a linear space before converting to dstInfo.
|
|
If behavior is SkTransferFunctionBehavior::kIgnore: source
|
|
pixels are treated as if they are linear, regardless of how they are encoded.
|
|
|
|
@param dstInfo destination width, height, SkColorType, SkAlphaType, SkColorSpace
|
|
@param dstPixels destination pixel storage
|
|
@param dstRowBytes destination row length
|
|
@param srcX column index whose absolute value is less than width()
|
|
@param srcY row index whose absolute value is less than height()
|
|
@param behavior one of: SkTransferFunctionBehavior::kRespect,
|
|
SkTransferFunctionBehavior::kIgnore
|
|
@return true if pixels are copied to dstPixels
|
|
*/
|
|
bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
|
|
int srcX, int srcY, SkTransferFunctionBehavior behavior) const;
|
|
|
|
/** Copies a SkRect of pixels to dstPixels. Copy starts at (srcX, srcY), and does not exceed
|
|
(this->width(), this->height()).
|
|
|
|
dstInfo specifies width, height, SkColorType, SkAlphaType, and
|
|
SkColorSpace of destination. dstRowBytes specifics the gap from one destination
|
|
row to the next. Returns true if pixels are copied. Returns false if:
|
|
- dstInfo.addr() equals nullptr
|
|
- dstRowBytes is less than dstInfo.minRowBytes()
|
|
- SkPixelRef is nullptr
|
|
|
|
Pixels are copied only if pixel conversion is possible. If this->colorType() is
|
|
kGray_8_SkColorType, or kAlpha_8_SkColorType; dstInfo.colorType() must match.
|
|
If this->colorType() is kGray_8_SkColorType, dstInfo.colorSpace() must match.
|
|
If this->alphaType() is kOpaque_SkAlphaType, dstInfo.alphaType() must
|
|
match. If this->colorSpace() is nullptr, dstInfo.colorSpace() must match. Returns
|
|
false if pixel conversion is not possible.
|
|
|
|
srcX and srcY may be negative to copy only top or left of source. Returns
|
|
false if width() or height() is zero or negative.
|
|
Returns false if abs(srcX) >= this->width(), or if abs(srcY) >= this->height().
|
|
|
|
@param dstInfo destination width, height, SkColorType, SkAlphaType, SkColorSpace
|
|
@param dstPixels destination pixel storage
|
|
@param dstRowBytes destination row length
|
|
@param srcX column index whose absolute value is less than width()
|
|
@param srcY row index whose absolute value is less than height()
|
|
@return true if pixels are copied to dstPixels
|
|
*/
|
|
bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
|
|
int srcX, int srcY) const {
|
|
return this->readPixels(dstInfo, dstPixels, dstRowBytes, srcX, srcY,
|
|
SkTransferFunctionBehavior::kRespect);
|
|
}
|
|
|
|
/** Copies a SkRect of pixels to dst. Copy starts at (srcX, srcY), and does not exceed
|
|
(this->width(), this->height()).
|
|
|
|
dst specifies width, height, SkColorType, SkAlphaType, SkColorSpace, pixel storage,
|
|
and row bytes of destination. dst.rowBytes() specifics the gap from one destination
|
|
row to the next. Returns true if pixels are copied. Returns false if:
|
|
- dst pixel storage equals nullptr
|
|
- dst.rowBytes is less than SkImageInfo::minRowBytes
|
|
- SkPixelRef is nullptr
|
|
|
|
Pixels are copied only if pixel conversion is possible. If this->colorType() is
|
|
kGray_8_SkColorType, or kAlpha_8_SkColorType; dst SkColorType must match.
|
|
If this->colorType() is kGray_8_SkColorType, dst SkColorSpace must match.
|
|
If this->alphaType() is kOpaque_SkAlphaType, dst SkAlphaType must
|
|
match. If this->colorSpace() is nullptr, dst SkColorSpace must match. Returns
|
|
false if pixel conversion is not possible.
|
|
|
|
srcX and srcY may be negative to copy only top or left of source. Returns
|
|
false if width() or height() is zero or negative.
|
|
Returns false if abs(srcX) >= this->width(), or if abs(srcY) >= this->height().
|
|
|
|
@param dst destination SkPixmap: SkImageInfo, pixels, row bytes
|
|
@param srcX column index whose absolute value is less than width()
|
|
@param srcY row index whose absolute value is less than height()
|
|
@return true if pixels are copied to dst
|
|
*/
|
|
bool readPixels(const SkPixmap& dst, int srcX, int srcY) const;
|
|
|
|
/** Copies a SkRect of pixels to dst. Copy starts at (0, 0), and does not exceed
|
|
(this->width(), this->height()).
|
|
|
|
dst specifies width, height, SkColorType, SkAlphaType, SkColorSpace, pixel storage,
|
|
and row bytes of destination. dst.rowBytes() specifics the gap from one destination
|
|
row to the next. Returns true if pixels are copied. Returns false if:
|
|
- dst pixel storage equals nullptr
|
|
- dst.rowBytes is less than SkImageInfo::minRowBytes
|
|
- SkPixelRef is nullptr
|
|
|
|
Pixels are copied only if pixel conversion is possible. If this->colorType() is
|
|
kGray_8_SkColorType, or kAlpha_8_SkColorType; dst SkColorType must match.
|
|
If this->colorType() is kGray_8_SkColorType, dst SkColorSpace must match.
|
|
If this->alphaType() is kOpaque_SkAlphaType, dst SkAlphaType must
|
|
match. If this->colorSpace() is nullptr, dst SkColorSpace must match. Returns
|
|
false if pixel conversion is not possible.
|
|
|
|
@param dst destination SkPixmap: SkImageInfo, pixels, row bytes
|
|
@return true if pixels are copied to dst
|
|
*/
|
|
bool readPixels(const SkPixmap& dst) const {
|
|
return this->readPixels(dst, 0, 0);
|
|
}
|
|
|
|
/** Copies a SkRect of pixels from src. Copy starts at (dstX, dstY), and does not exceed
|
|
(src.width(), src.height()).
|
|
|
|
src specifies width, height, SkColorType, SkAlphaType, SkColorSpace, pixel storage,
|
|
and row bytes of source. src.rowBytes() specifics the gap from one source
|
|
row to the next. Returns true if pixels are copied. Returns false if:
|
|
- src pixel storage equals nullptr
|
|
- src.rowBytes is less than SkImageInfo::minRowBytes
|
|
- SkPixelRef is nullptr
|
|
|
|
Pixels are copied only if pixel conversion is possible. If this->colorType() is
|
|
kGray_8_SkColorType, or kAlpha_8_SkColorType; src SkColorType must match.
|
|
If this->colorType() is kGray_8_SkColorType, src SkColorSpace must match.
|
|
If this->alphaType() is kOpaque_SkAlphaType, src SkAlphaType must
|
|
match. If this->colorSpace() is nullptr, src SkColorSpace must match. Returns
|
|
false if pixel conversion is not possible.
|
|
|
|
dstX and dstY may be negative to copy only top or left of source. Returns
|
|
false if width() or height() is zero or negative.
|
|
Returns false if abs(dstX) >= this->width(), or if abs(dstY) >= this->height().
|
|
|
|
@param src source SkPixmap: SkImageInfo, pixels, row bytes
|
|
@param dstX column index whose absolute value is less than width()
|
|
@param dstY row index whose absolute value is less than height()
|
|
@return true if src pixels are copied to SkBitmap
|
|
*/
|
|
bool writePixels(const SkPixmap& src, int dstX, int dstY) {
|
|
return this->writePixels(src, dstX, dstY, SkTransferFunctionBehavior::kRespect);
|
|
}
|
|
|
|
/** Copies a SkRect of pixels from src. Copy starts at (0, 0), and does not exceed
|
|
(src.width(), src.height()).
|
|
|
|
src specifies width, height, SkColorType, SkAlphaType, SkColorSpace, pixel storage,
|
|
and row bytes of source. src.rowBytes() specifics the gap from one source
|
|
row to the next. Returns true if pixels are copied. Returns false if:
|
|
- src pixel storage equals nullptr
|
|
- src.rowBytes is less than SkImageInfo::minRowBytes
|
|
- SkPixelRef is nullptr
|
|
|
|
Pixels are copied only if pixel conversion is possible. If this->colorType() is
|
|
kGray_8_SkColorType, or kAlpha_8_SkColorType; src SkColorType must match.
|
|
If this->colorType() is kGray_8_SkColorType, src SkColorSpace must match.
|
|
If this->alphaType() is kOpaque_SkAlphaType, src SkAlphaType must
|
|
match. If this->colorSpace() is nullptr, src SkColorSpace must match. Returns
|
|
false if pixel conversion is not possible.
|
|
|
|
@param src source SkPixmap: SkImageInfo, pixels, row bytes
|
|
@return true if src pixels are copied to SkBitmap
|
|
*/
|
|
bool writePixels(const SkPixmap& src) {
|
|
return this->writePixels(src, 0, 0);
|
|
}
|
|
|
|
/** Copies a SkRect of pixels from src. Copy starts at (0, 0), and does not exceed
|
|
(src.width(), src.height()).
|
|
|
|
src specifies width, height, SkColorType, SkAlphaType, SkColorSpace, pixel storage,
|
|
and row bytes of source. src.rowBytes() specifics the gap from one source
|
|
row to the next. Returns true if pixels are copied. Returns false if:
|
|
- src pixel storage equals nullptr
|
|
- src.rowBytes is less than SkImageInfo::minRowBytes
|
|
- SkPixelRef is nullptr
|
|
|
|
Pixels are copied only if pixel conversion is possible. If this->colorType() is
|
|
kGray_8_SkColorType, or kAlpha_8_SkColorType; src SkColorType must match.
|
|
If this->colorType() is kGray_8_SkColorType, src SkColorSpace must match.
|
|
If this->alphaType() is kOpaque_SkAlphaType, src SkAlphaType must
|
|
match. If this->colorSpace() is nullptr, src SkColorSpace must match. Returns
|
|
false if pixel conversion is not possible. Returns false if width() or height()
|
|
is zero or negative.
|
|
|
|
If behavior is SkTransferFunctionBehavior::kRespect: converts src
|
|
pixels to a linear space before converting to SkImageInfo.
|
|
If behavior is SkTransferFunctionBehavior::kIgnore: src
|
|
pixels are treated as if they are linear, regardless of how they are encoded.
|
|
|
|
@param src source SkPixmap: SkImageInfo, pixels, row bytes
|
|
@param x column index whose absolute value is less than width()
|
|
@param y row index whose absolute value is less than height()
|
|
@param behavior one of: SkTransferFunctionBehavior::kRespect,
|
|
SkTransferFunctionBehavior::kIgnore
|
|
@return true if src pixels are copied to SkBitmap
|
|
*/
|
|
bool writePixels(const SkPixmap& src, int x, int y, SkTransferFunctionBehavior behavior);
|
|
|
|
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
|
|
/** Android framework only.
|
|
|
|
@return true if setHasHardwareMipMap() has been called with true
|
|
*/
|
|
bool hasHardwareMipMap() const {
|
|
return (fFlags & kHasHardwareMipMap_Flag) != 0;
|
|
}
|
|
|
|
/** Android framework only.
|
|
|
|
@param hasHardwareMipMap sets state
|
|
*/
|
|
void setHasHardwareMipMap(bool hasHardwareMipMap) {
|
|
if (hasHardwareMipMap) {
|
|
fFlags |= kHasHardwareMipMap_Flag;
|
|
} else {
|
|
fFlags &= ~kHasHardwareMipMap_Flag;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/** Sets dst to alpha described by pixels. Returns false if dst cannot be written to
|
|
or dst pixels cannot be allocated.
|
|
|
|
Uses HeapAllocator to reserve memory for dst SkPixelRef.
|
|
|
|
@param dst holds SkPixelRef to fill with alpha layer
|
|
@return true if alpha layer was constructed in dst SkPixelRef
|
|
*/
|
|
bool extractAlpha(SkBitmap* dst) const {
|
|
return this->extractAlpha(dst, nullptr, nullptr, nullptr);
|
|
}
|
|
|
|
/** Sets dst to alpha described by pixels. Returns false if dst cannot be written to
|
|
or dst pixels cannot be allocated.
|
|
|
|
If paint is not nullptr and contains SkMaskFilter, SkMaskFilter::filterMask
|
|
generates mask alpha from SkBitmap. Uses HeapAllocator to reserve memory for dst
|
|
SkPixelRef. Sets offset to top-left position for dst for alignment with SkBitmap;
|
|
(0, 0) unless SkMaskFilter generates mask.
|
|
|
|
@param dst holds SkPixelRef to fill with alpha layer
|
|
@param paint holds optional SkMaskFilter; may be nullptr
|
|
@param offset top-left position for dst; may be nullptr
|
|
@return true if alpha layer was constructed in dst SkPixelRef
|
|
*/
|
|
bool extractAlpha(SkBitmap* dst, const SkPaint* paint,
|
|
SkIPoint* offset) const {
|
|
return this->extractAlpha(dst, paint, nullptr, offset);
|
|
}
|
|
|
|
/** Sets dst to alpha described by pixels. Returns false if dst cannot be written to
|
|
or dst pixels cannot be allocated.
|
|
|
|
If paint is not nullptr and contains SkMaskFilter, SkMaskFilter::filterMask
|
|
generates mask alpha from SkBitmap. allocator may reference a custom allocation
|
|
class or be set to nullptr to use HeapAllocator. Sets offset to top-left
|
|
position for dst for alignment with SkBitmap; (0, 0) unless SkMaskFilter generates
|
|
mask.
|
|
|
|
@param dst holds SkPixelRef to fill with alpha layer
|
|
@param paint holds optional SkMaskFilter; may be nullptr
|
|
@param allocator method to reserve memory for SkPixelRef; may be nullptr
|
|
@param offset top-left position for dst; may be nullptr
|
|
@return true if alpha layer was constructed in dst SkPixelRef
|
|
*/
|
|
bool extractAlpha(SkBitmap* dst, const SkPaint* paint, Allocator* allocator,
|
|
SkIPoint* offset) const;
|
|
|
|
/** Copies SkBitmap pixel address, row bytes, and SkImageInfo to pixmap, if address
|
|
is available, and returns true. If pixel address is not available, return
|
|
false and leave pixmap unchanged.
|
|
|
|
pixmap contents become invalid on any future change to SkBitmap.
|
|
|
|
@param pixmap storage for pixel state if pixels are readable; otherwise, ignored
|
|
@return true if SkBitmap has direct access to pixels
|
|
*/
|
|
bool peekPixels(SkPixmap* pixmap) const;
|
|
|
|
/** Asserts if internal values are illegal or inconsistent. Only available if
|
|
SK_DEBUG is defined at compile time.
|
|
*/
|
|
SkDEBUGCODE(void validate() const;)
|
|
|
|
/** \class SkBitmap::Allocator
|
|
Abstract subclass of HeapAllocator.
|
|
*/
|
|
class Allocator : public SkRefCnt {
|
|
public:
|
|
|
|
/** Allocates the pixel memory for the bitmap, given its dimensions and
|
|
color type. Returns true on success, where success means either setPixels()
|
|
or setPixelRef() was called.
|
|
|
|
@param bitmap SkBitmap containing SkImageInfo as input, and SkPixelRef as output
|
|
@return true if SkPixelRef was allocated
|
|
*/
|
|
virtual bool allocPixelRef(SkBitmap* bitmap) = 0;
|
|
private:
|
|
typedef SkRefCnt INHERITED;
|
|
};
|
|
|
|
/** \class SkBitmap::HeapAllocator
|
|
Subclass of allocator that returns a SkPixelRef that allocates its pixel
|
|
memory from the heap. This is the default allocator invoked by
|
|
allocPixels().
|
|
*/
|
|
class HeapAllocator : public Allocator {
|
|
public:
|
|
|
|
/** Allocates the pixel memory for the bitmap, given its dimensions and
|
|
color type. Returns true on success, where success means either setPixels()
|
|
or setPixelRef() was called.
|
|
|
|
@param bitmap SkBitmap containing SkImageInfo as input, and SkPixelRef as output
|
|
@return true if pixels are allocated
|
|
*/
|
|
bool allocPixelRef(SkBitmap* bitmap) override;
|
|
};
|
|
|
|
/** macro expands to: void toString(SkString* str) const;
|
|
Creates string representation. The representation is read by
|
|
internal debugging tools. The interface and implementation may be
|
|
suppressed by defining SK_IGNORE_TO_STRING.
|
|
|
|
@param str storage for string representation
|
|
*/
|
|
SK_TO_STRING_NONVIRT()
|
|
|
|
private:
|
|
enum Flags {
|
|
kImageIsVolatile_Flag = 0x02,
|
|
#ifdef SK_BUILD_FOR_ANDROID
|
|
/* A hint for the renderer responsible for drawing this bitmap
|
|
* indicating that it should attempt to use mipmaps when this bitmap
|
|
* is drawn scaled down.
|
|
*/
|
|
kHasHardwareMipMap_Flag = 0x08,
|
|
#endif
|
|
};
|
|
|
|
sk_sp<SkPixelRef> fPixelRef;
|
|
void* fPixels;
|
|
SkIPoint fPixelRefOrigin;
|
|
SkImageInfo fInfo;
|
|
uint32_t fRowBytes;
|
|
uint8_t fFlags;
|
|
|
|
/* Unreference any pixelrefs
|
|
*/
|
|
void freePixels();
|
|
void updatePixelsFromRef();
|
|
|
|
static void WriteRawPixels(SkWriteBuffer*, const SkBitmap&);
|
|
static bool ReadRawPixels(SkReadBuffer*, SkBitmap*);
|
|
|
|
friend class SkReadBuffer; // unflatten, rawpixels
|
|
friend class SkBinaryWriteBuffer; // rawpixels
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
inline uint32_t* SkBitmap::getAddr32(int x, int y) const {
|
|
SkASSERT(fPixels);
|
|
SkASSERT(4 == this->bytesPerPixel());
|
|
SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
|
|
return (uint32_t*)((char*)fPixels + y * fRowBytes + (x << 2));
|
|
}
|
|
|
|
inline uint16_t* SkBitmap::getAddr16(int x, int y) const {
|
|
SkASSERT(fPixels);
|
|
SkASSERT(2 == this->bytesPerPixel());
|
|
SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
|
|
return (uint16_t*)((char*)fPixels + y * fRowBytes + (x << 1));
|
|
}
|
|
|
|
inline uint8_t* SkBitmap::getAddr8(int x, int y) const {
|
|
SkASSERT(fPixels);
|
|
SkASSERT(1 == this->bytesPerPixel());
|
|
SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
|
|
return (uint8_t*)fPixels + y * fRowBytes + x;
|
|
}
|
|
|
|
#endif
|