#include <SkBitmap.h>

Classes
class	HeapAllocator

Public Types
enum	AllocFlags { kZeroPixels_AllocFlag = 1 << 0 }

Public Member Functions
	SkBitmap ()

	SkBitmap (const SkBitmap &src)

	SkBitmap (SkBitmap &&src)

	~SkBitmap ()

SkBitmap &	operator= (const SkBitmap &src)

SkBitmap &	operator= (SkBitmap &&src)

void	swap (SkBitmap &other)

const SkPixmap &	pixmap () const

const SkImageInfo &	info () const

int	width () const

int	height () const

SkColorType	colorType () const

SkAlphaType	alphaType () const

SkColorSpace *	colorSpace () const

sk_sp< SkColorSpace >	refColorSpace () const

int	bytesPerPixel () const

int	rowBytesAsPixels () const

int	shiftPerPixel () const

bool	empty () const

bool	isNull () const

bool	drawsNothing () const

size_t	rowBytes () const

bool	setAlphaType (SkAlphaType alphaType)

void	setColorSpace (sk_sp< SkColorSpace > colorSpace)

void *	getPixels () const

size_t	computeByteSize () const

bool	isImmutable () const

void	setImmutable ()

bool	isOpaque () const

void	reset ()

void	getBounds (SkRect *bounds) const

void	getBounds (SkIRect *bounds) const

SkIRect	bounds () const

SkISize	dimensions () const

SkIRect	getSubset () const

bool	setInfo (const SkImageInfo &imageInfo, size_t rowBytes=0)

bool	tryAllocPixelsFlags (const SkImageInfo &info, uint32_t flags)

void	allocPixelsFlags (const SkImageInfo &info, uint32_t flags)

bool	tryAllocPixels (const SkImageInfo &info, size_t rowBytes)

void	allocPixels (const SkImageInfo &info, size_t rowBytes)

bool	tryAllocPixels (const SkImageInfo &info)

void	allocPixels (const SkImageInfo &info)

bool	tryAllocN32Pixels (int width, int height, bool isOpaque=false)

void	allocN32Pixels (int width, int height, bool isOpaque=false)

bool	installPixels (const SkImageInfo &info, void pixels, size_t rowBytes, void(releaseProc)(void addr, void context), void *context)

bool	installPixels (const SkImageInfo &info, void *pixels, size_t rowBytes)

bool	installPixels (const SkPixmap &pixmap)

bool	installMaskPixels (SkMaskBuilder &mask)

void	setPixels (void *pixels)

bool	tryAllocPixels ()

void	allocPixels ()

bool	tryAllocPixels (Allocator *allocator)

void	allocPixels (Allocator *allocator)

SkPixelRef *	pixelRef () const

SkIPoint	pixelRefOrigin () const

void	setPixelRef (sk_sp< SkPixelRef > pixelRef, int dx, int dy)

bool	readyToDraw () const

uint32_t	getGenerationID () const

void	notifyPixelsChanged () const

void	eraseColor (SkColor4f) const

void	eraseColor (SkColor c) const

void	eraseARGB (U8CPU a, U8CPU r, U8CPU g, U8CPU b) const

void	erase (SkColor4f c, const SkIRect &area) const

void	erase (SkColor c, const SkIRect &area) const

void	eraseArea (const SkIRect &area, SkColor c) const

SkColor	getColor (int x, int y) const

SkColor4f	getColor4f (int x, int y) const

float	getAlphaf (int x, int y) const

void *	getAddr (int x, int y) const

uint32_t *	getAddr32 (int x, int y) const

uint16_t *	getAddr16 (int x, int y) const

uint8_t *	getAddr8 (int x, int y) const

bool	extractSubset (SkBitmap *dst, const SkIRect &subset) const

bool	readPixels (const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY) const

bool	readPixels (const SkPixmap &dst, int srcX, int srcY) const

bool	readPixels (const SkPixmap &dst) const

bool	writePixels (const SkPixmap &src, int dstX, int dstY)

bool	writePixels (const SkPixmap &src)

bool	extractAlpha (SkBitmap *dst) const

bool	extractAlpha (SkBitmap dst, const SkPaint paint, SkIPoint *offset) const

bool	extractAlpha (SkBitmap dst, const SkPaint paint, Allocator allocator, SkIPoint offset) const

bool	peekPixels (SkPixmap *pixmap) const

sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &, const SkMatrix *localMatrix=nullptr) const

sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix *lm=nullptr) const

sk_sp< SkImage >	asImage () const

Static Public Member Functions
static bool	ComputeIsOpaque (const SkBitmap &bm)

Public Attributes
class SK_API	Allocator

Friends
class	SkImage_Raster

class	SkReadBuffer

class	GrProxyProvider

Detailed Description

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 member functions. 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.

Definition at line 59 of file SkBitmap.h.

Member Enumeration Documentation

◆ AllocFlags

enum SkBitmap::AllocFlags

Enumerator
kZeroPixels_AllocFlag	zero pixel memory. No effect. This is the default.

Definition at line 434 of file SkBitmap.h.

                    {
        kZeroPixels_AllocFlag = 1 << 0, //!< zero pixel memory.  No effect.  This is the default.
    };

Constructor & Destructor Documentation

◆ SkBitmap() [1/3]

SkBitmap::SkBitmap ( )

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).

Use setInfo() to associate SkColorType, SkAlphaType, width, and height after SkBitmap has been created.

Returns: empty SkBitmap

example: https://fiddle.skia.org/c/@Bitmap_empty_constructor

Definition at line 43 of file SkBitmap.cpp.

43{}

◆ SkBitmap() [2/3]

SkBitmap::SkBitmap ( const SkBitmap & src )

Copies settings from src to returned SkBitmap. Shares pixels if src has pixels allocated, so both bitmaps reference the same pixels.

Parameters

src	SkBitmap to copy SkImageInfo, and share SkPixelRef

Returns: copy of src

example: https://fiddle.skia.org/c/@Bitmap_copy_const_SkBitmap

Definition at line 45 of file SkBitmap.cpp.

    : fPixelRef      (src.fPixelRef)
    , fPixmap        (src.fPixmap)
    , fMips          (src.fMips)
{
    SkDEBUGCODE(src.validate();)
    SkDEBUGCODE(this->validate();)
}

◆ SkBitmap() [3/3]

SkBitmap::SkBitmap ( SkBitmap && src )

Copies settings from src to returned SkBitmap. Moves ownership of src pixels to SkBitmap.

Parameters

src	SkBitmap to copy SkImageInfo, and reassign SkPixelRef

Returns: copy of src

example: https://fiddle.skia.org/c/@Bitmap_move_SkBitmap

Definition at line 54 of file SkBitmap.cpp.

    : fPixelRef      (std::move(other.fPixelRef))
    , fPixmap        (std::move(other.fPixmap))
    , fMips          (std::move(other.fMips))
{
    SkASSERT(!other.fPixelRef);
    other.fPixmap.reset();
}

◆ ~SkBitmap()

SkBitmap::~SkBitmap ( )

Decrements SkPixelRef reference count, if SkPixelRef is not nullptr.

Definition at line 63 of file SkBitmap.cpp.

63{}

Member Function Documentation

◆ allocN32Pixels()

void SkBitmap::allocN32Pixels	(	int	width,
		int	height,
		bool	isOpaque = `false`
	)

Sets SkImageInfo to width, height, and the native color type; and allocates pixel memory. If isOpaque is true, sets SkImageInfo to kOpaque_SkAlphaType; otherwise, sets to kPremul_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 SkPMColor, the native pixel arrangement on the platform. SkBitmap drawn to output device skips converting its pixel format.

Parameters

width	pixel column count; must be zero or greater
height	pixel row count; must be zero or greater
isOpaque	true if pixels do not have transparency

example: https://fiddle.skia.org/c/@Bitmap_allocN32Pixels

Definition at line 232 of file SkBitmap.cpp.

                                                                  {
    SkImageInfo info = SkImageInfo::MakeN32(width, height,
                                        isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
    this->allocPixels(info);
}

◆ allocPixels() [1/4]

void SkBitmap::allocPixels ( )

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 fails. Abort steps may be provided by the user at compile time by defining SK_ABORT.

example: https://fiddle.skia.org/c/@Bitmap_allocPixels_3

Definition at line 238 of file SkBitmap.cpp.

                           {
    this->allocPixels((Allocator*)nullptr);
}

◆ allocPixels() [2/4]

void SkBitmap::allocPixels ( 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.

Parameters

allocator instance of SkBitmap::Allocator instantiation

example: https://fiddle.skia.org/c/@Bitmap_allocPixels_4

Definition at line 242 of file SkBitmap.cpp.

                                               {
    if (!this->tryAllocPixels(allocator)) {
        const SkImageInfo& info = this->info();
        SK_ABORT("SkBitmap::tryAllocPixels failed "
                 "ColorType:%d AlphaType:%d [w:%d h:%d] rb:%zu",
                 info.colorType(), info.alphaType(), info.width(), info.height(), this->rowBytes());
    }
}

◆ allocPixels() [3/4]

void SkBitmap::allocPixels ( const SkImageInfo & info )

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. 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().

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace

example: https://fiddle.skia.org/c/@Bitmap_allocPixels_2

Definition at line 265 of file SkBitmap.cpp.

                                                  {
    this->allocPixels(info, info.minRowBytes());
}

◆ allocPixels() [4/4]

void SkBitmap::allocPixels	(	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. 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().

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace
rowBytes	size of pixel row or larger; may be zero

example: https://fiddle.skia.org/c/@Bitmap_allocPixels

Definition at line 258 of file SkBitmap.cpp.

                                                                   {
    SkASSERTF_RELEASE(this->tryAllocPixels(info, rowBytes),
                      "ColorType:%d AlphaType:%d [w:%d h:%d] rb:%zu",
                      info.colorType(), info.alphaType(), info.width(), info.height(),
                      this->rowBytes());
}

◆ allocPixelsFlags()

void SkBitmap::allocPixelsFlags	(	const SkImageInfo &	info,
		uint32_t	flags
	)

Sets SkImageInfo to info following the rules in setInfo() and allocates pixel memory. Memory is zeroed.

Aborts execution if SkImageInfo could not be set, or memory could not be allocated, 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 calloc().

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace
flags	kZeroPixels_AllocFlag, or zero

example: https://fiddle.skia.org/c/@Bitmap_allocPixelsFlags

Definition at line 251 of file SkBitmap.cpp.

                                                                       {
    SkASSERTF_RELEASE(this->tryAllocPixelsFlags(info, flags),
                      "ColorType:%d AlphaType:%d [w:%d h:%d] rb:%zu flags: 0x%x",
                      info.colorType(), info.alphaType(), info.width(), info.height(),
                      this->rowBytes(), flags);
}

◆ alphaType()

SkAlphaType SkBitmap::alphaType ( ) const

inline

Definition at line 162 of file SkBitmap.h.

162{ return fPixmap.alphaType(); }

SkPixmap::alphaType

SkAlphaType alphaType() const

Definition: SkPixmap.h:175

◆ asImage()

sk_sp< SkImage > SkBitmap::asImage ( ) const

Returns a new image from the bitmap. If the bitmap is marked immutable, this will share the pixel buffer. If not, it will make a copy of the pixels for the image.

Definition at line 645 of file SkBitmap.cpp.

645{ return SkImages::RasterFromBitmap(*this); }

SkImages::RasterFromBitmap

SK_API sk_sp< SkImage > RasterFromBitmap(const SkBitmap &bitmap)

Definition: SkImage_RasterFactories.cpp:74

◆ bounds()

SkIRect SkBitmap::bounds ( ) const

inline

Returns SkIRect { 0, 0, width(), height() }.

Returns: integral rectangle from origin to width() and height()

Definition at line 382 of file SkBitmap.h.

382{ return fPixmap.info().bounds(); }

SkPixmap::info

const SkImageInfo & info() const

Definition: SkPixmap.h:135

SkImageInfo::bounds

SkIRect bounds() const

Definition: SkImageInfo.h:427

◆ bytesPerPixel()

int SkBitmap::bytesPerPixel ( ) const

inline

Returns number of bytes per pixel required by SkColorType. Returns zero if colorType( is kUnknown_SkColorType.

Returns: bytes in pixel

Definition at line 187 of file SkBitmap.h.

187{ return fPixmap.info().bytesPerPixel(); }

SkImageInfo::bytesPerPixel

int bytesPerPixel() const

Definition: SkImageInfo.h:492

◆ colorSpace()

SkColorSpace * SkBitmap::colorSpace ( ) const

Returns SkColorSpace, the range of colors, associated with SkImageInfo. The reference count of SkColorSpace is unchanged. The returned SkColorSpace is immutable.

Returns: SkColorSpace in SkImageInfo, or nullptr

Definition at line 108 of file SkBitmap.cpp.

108{ return fPixmap.colorSpace(); }

SkPixmap::colorSpace

SkColorSpace * colorSpace() const

Definition: SkPixmap.cpp:61

◆ colorType()

SkColorType SkBitmap::colorType ( ) const

inline

Definition at line 160 of file SkBitmap.h.

160{ return fPixmap.colorType(); }

SkPixmap::colorType

SkColorType colorType() const

Definition: SkPixmap.h:173

◆ computeByteSize()

size_t SkBitmap::computeByteSize ( ) const

inline

Returns minimum memory required for pixel storage. Does not include unused memory on last row when rowBytesAsPixels() exceeds width(). Returns SIZE_MAX 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.

Returns: size in bytes of image buffer

Definition at line 293 of file SkBitmap.h.

293{ return fPixmap.computeByteSize(); }

SkPixmap::computeByteSize

size_t computeByteSize() const

Definition: SkPixmap.h:231

◆ ComputeIsOpaque()

static bool SkBitmap::ComputeIsOpaque ( const SkBitmap & bm )

inlinestatic

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.

Parameters

bm	SkBitmap to check

Returns: true if all pixels have opaque values or SkColorType is opaque

Definition at line 358 of file SkBitmap.h.

                                                    {
        return bm.pixmap().computeIsOpaque();
    }

◆ dimensions()

SkISize SkBitmap::dimensions ( ) const

inline

Returns SkISize { width(), height() }.

Returns: integral size of width() and height()

Definition at line 388 of file SkBitmap.h.

388{ return fPixmap.info().dimensions(); }

SkImageInfo::dimensions

SkISize dimensions() const

Definition: SkImageInfo.h:421

◆ drawsNothing()

bool SkBitmap::drawsNothing ( ) const

inline

Returns true if width() or height() are zero, or if SkPixelRef is nullptr. If true, SkBitmap has no effect when drawn or drawn into.

Returns: true if drawing has no effect

Definition at line 226 of file SkBitmap.h.

                              {
        return this->empty() || this->isNull();
    }

◆ empty()

bool SkBitmap::empty ( ) const

inline

Returns true if either width() or height() are zero.

Does not check if SkPixelRef is nullptr; call drawsNothing() to check width(), height(), and SkPixelRef.

Returns: true if dimensions do not enclose area

Definition at line 210 of file SkBitmap.h.

210{ return fPixmap.info().isEmpty(); }

SkImageInfo::isEmpty

bool isEmpty() const

Definition: SkImageInfo.h:399

◆ erase() [1/2]

void SkBitmap::erase	(	SkColor	c,
		const SkIRect &	area
	)		const

Replaces pixel values inside area with c. interpreted as being in the sRGB SkColorSpace. If area does not intersect bounds(), call has no effect.

If the colorType() is kGray_8_SkColorType or kRGB_565_SkColorType, then alpha is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType, then RGB is ignored.

Input color is ultimately converted to an SkColor4f, so erase(SkColor4f c) will have higher color resolution.

Parameters

c	unpremultiplied color
area	rectangle to fill

example: https://fiddle.skia.org/c/@Bitmap_erase

Definition at line 438 of file SkBitmap.cpp.

                                                         {
    this->erase(SkColor4f::FromColor(c), area);
}

◆ erase() [2/2]

void SkBitmap::erase	(	SkColor4f	c,
		const SkIRect &	area
	)		const

Replaces pixel values inside area with c. interpreted as being in the sRGB SkColorSpace. If area does not intersect bounds(), call has no effect.

If the colorType() is kGray_8_SkColorType or kRGB_565_SkColorType, then alpha is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType, then RGB is ignored.

Parameters

c	unpremultiplied color
area	rectangle to fill

example: https://fiddle.skia.org/c/@Bitmap_erase

Definition at line 420 of file SkBitmap.cpp.

                                                           {
    SkDEBUGCODE(this->validate();)
 
    if (kUnknown_SkColorType == this->colorType()) {
        // TODO: can we ASSERT that we never get here?
        return; // can't erase. Should we bzero so the memory is not uninitialized?
    }
 
    SkPixmap result;
    if (!this->peekPixels(&result)) {
        return;
    }
 
    if (result.erase(c, &area)) {
        this->notifyPixelsChanged();
    }
}

◆ eraseArea()

void SkBitmap::eraseArea	(	const SkIRect &	area,
		SkColor	c
	)		const

inline

Deprecated.

Definition at line 854 of file SkBitmap.h.

                                                         {
        this->erase(c, area);
    }

◆ eraseARGB()

void SkBitmap::eraseARGB	(	U8CPU	a,
		U8CPU	r,
		U8CPU	g,
		U8CPU	b
	)		const

inline

Replaces pixel values with unpremultiplied color built from a, r, g, and b, interpreted as being in the sRGB SkColorSpace. All pixels contained by bounds() are affected. If the colorType() is kGray_8_SkColorType or kRGB_565_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.

Parameters

a	amount of alpha, from fully transparent (0) to fully opaque (255)
r	amount of red, from no red (0) to full red (255)
g	amount of green, from no green (0) to full green (255)
b	amount of blue, from no blue (0) to full blue (255)

Definition at line 817 of file SkBitmap.h.

                                                             {
        this->eraseColor(SkColorSetARGB(a, r, g, b));
    }

◆ eraseColor() [1/2]

void SkBitmap::eraseColor ( SkColor c ) const

Replaces pixel values with c, interpreted as being in the sRGB SkColorSpace. All pixels contained by bounds() are affected. If the colorType() is kGray_8_SkColorType or kRGB_565_SkColorType, then alpha is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType, then RGB is ignored.

Input color is ultimately converted to an SkColor4f, so eraseColor(SkColor4f c) will have higher color resolution.

Parameters

c	unpremultiplied color.

example: https://fiddle.skia.org/c/@Bitmap_eraseColor

Definition at line 446 of file SkBitmap.cpp.

                                         {
    this->erase(SkColor4f::FromColor(c), SkIRect::MakeWH(this->width(), this->height()));
}

◆ eraseColor() [2/2]

void SkBitmap::eraseColor ( SkColor4f c ) const

Replaces pixel values with c, interpreted as being in the sRGB SkColorSpace. All pixels contained by bounds() are affected. If the colorType() is kGray_8_SkColorType or kRGB_565_SkColorType, then alpha is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType, then RGB is ignored.

Parameters

c	unpremultiplied color

example: https://fiddle.skia.org/c/@Bitmap_eraseColor

Definition at line 442 of file SkBitmap.cpp.

                                           {
    this->erase(c, SkIRect::MakeWH(this->width(), this->height()));
}

◆ extractAlpha() [1/3]

bool SkBitmap::extractAlpha ( SkBitmap * dst ) const

inline

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.

Parameters

dst	holds SkPixelRef to fill with alpha layer

Returns: true if alpha layer was constructed in dst SkPixelRef

Definition at line 1134 of file SkBitmap.h.

                                           {
        return this->extractAlpha(dst, nullptr, nullptr, nullptr);
    }

◆ extractAlpha() [2/3]

bool SkBitmap::extractAlpha	(	SkBitmap *	dst,
		const SkPaint *	paint,
		Allocator *	allocator,
		SkIPoint *	offset
	)		const

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 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.

Parameters

dst	holds SkPixelRef to fill with alpha layer
paint	holds optional SkMaskFilter; may be nullptr
allocator	function to reserve memory for SkPixelRef; may be nullptr
offset	top-left position for dst; may be nullptr

Returns: true if alpha layer was constructed in dst SkPixelRef

Definition at line 539 of file SkBitmap.cpp.

                                                                          {
    SkDEBUGCODE(this->validate();)
 
    SkBitmap    tmpBitmap;
    SkMatrix    identity;
    SkMaskBuilder      srcM, dstM;
 
    if (this->width() == 0 || this->height() == 0) {
        return false;
    }
    srcM.bounds().setWH(this->width(), this->height());
    srcM.rowBytes() = SkAlign4(this->width());
    srcM.format() = SkMask::kA8_Format;
 
    SkMaskFilter* filter = paint ? paint->getMaskFilter() : nullptr;
 
    // compute our (larger?) dst bounds if we have a filter
    if (filter) {
        identity.reset();
        if (!as_MFB(filter)->filterMask(&dstM, srcM, identity, nullptr)) {
            goto NO_FILTER_CASE;
        }
        dstM.rowBytes() = SkAlign4(dstM.fBounds.width());
    } else {
    NO_FILTER_CASE:
        tmpBitmap.setInfo(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
        if (!tmpBitmap.tryAllocPixels(allocator)) {
            // Allocation of pixels for alpha bitmap failed.
            SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                    tmpBitmap.width(), tmpBitmap.height());
            return false;
        }
        GetBitmapAlpha(*this, tmpBitmap.getAddr8(0, 0), srcM.fRowBytes);
        if (offset) {
            offset->set(0, 0);
        }
        tmpBitmap.swap(*dst);
        return true;
    }
    srcM.image() = SkMaskBuilder::AllocImage(srcM.computeImageSize());
    SkAutoMaskFreeImage srcCleanup(srcM.image());
 
    GetBitmapAlpha(*this, srcM.image(), srcM.fRowBytes);
    if (!as_MFB(filter)->filterMask(&dstM, srcM, identity, nullptr)) {
        goto NO_FILTER_CASE;
    }
    SkAutoMaskFreeImage dstCleanup(dstM.image());
 
    tmpBitmap.setInfo(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
                      dstM.fRowBytes);
    if (!tmpBitmap.tryAllocPixels(allocator)) {
        // Allocation of pixels for alpha bitmap failed.
        SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                tmpBitmap.width(), tmpBitmap.height());
        return false;
    }
    memcpy(tmpBitmap.getPixels(), dstM.fImage, dstM.computeImageSize());
    if (offset) {
        offset->set(dstM.fBounds.fLeft, dstM.fBounds.fTop);
    }
    SkDEBUGCODE(tmpBitmap.validate();)
 
    tmpBitmap.swap(*dst);
    return true;
}

◆ extractAlpha() [3/3]

bool SkBitmap::extractAlpha	(	SkBitmap *	dst,
		const SkPaint *	paint,
		SkIPoint *	offset
	)		const

inline

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 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.

Parameters

dst	holds SkPixelRef to fill with alpha layer
paint	holds optional SkMaskFilter; may be nullptr
offset	top-left position for dst; may be nullptr

Returns: true if alpha layer was constructed in dst SkPixelRef

Definition at line 1151 of file SkBitmap.h.

                                              {
        return this->extractAlpha(dst, paint, nullptr, offset);
    }

◆ extractSubset()

bool SkBitmap::extractSubset	(	SkBitmap *	dst,
		const SkIRect &	subset
	)		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.

Return false if:

dst is nullptr
SkPixelRef is nullptr
subset does not intersect bounds()

Parameters

dst	SkBitmap set to subset
subset	rectangle of pixels to reference

Returns: true if dst is replaced by subset

example: https://fiddle.skia.org/c/@Bitmap_extractSubset

Definition at line 453 of file SkBitmap.cpp.

                                                                          {
    SkDEBUGCODE(this->validate();)
 
    if (nullptr == result || !fPixelRef) {
        return false;   // no src pixels
    }
 
    SkIRect srcRect, r;
    srcRect.setWH(this->width(), this->height());
    if (!r.intersect(srcRect, subset)) {
        return false;   // r is empty (i.e. no intersection)
    }
 
    // If the upper left of the rectangle was outside the bounds of this SkBitmap, we should have
    // exited above.
    SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
    SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
 
    SkBitmap dst;
    dst.setInfo(this->info().makeDimensions(r.size()), this->rowBytes());
 
    if (fPixelRef) {
        SkIPoint origin = this->pixelRefOrigin();
        // share the pixelref with a custom offset
        dst.setPixelRef(fPixelRef, origin.x() + r.fLeft, origin.y() + r.fTop);
    }
    SkDEBUGCODE(dst.validate();)
 
    // we know we're good, so commit to result
    result->swap(dst);
    return true;
}

◆ getAddr()

void * SkBitmap::getAddr	(	int	x,
		int	y
	)		const

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().

Parameters

x	column index, zero or greater, and less than width()
y	row index, zero or greater, and less than height()

Returns: generic pointer to pixel

example: https://fiddle.skia.org/c/@Bitmap_getAddr

Definition at line 406 of file SkBitmap.cpp.

                                          {
    SkASSERT((unsigned)x < (unsigned)this->width());
    SkASSERT((unsigned)y < (unsigned)this->height());
 
    char* base = (char*)this->getPixels();
    if (base) {
        base += (y * this->rowBytes()) + (x << this->shiftPerPixel());
    }
    return base;
}

◆ getAddr16()

uint16_t * SkBitmap::getAddr16	(	int	x,
		int	y
	)		const

inline

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()

Parameters

x	column index, zero or greater, and less than width()
y	row index, zero or greater, and less than height()

Returns: unsigned 16-bit pointer to pixel at (x, y)

Definition at line 1265 of file SkBitmap.h.

                                                       {
    SkASSERT(fPixmap.addr());
    return fPixmap.writable_addr16(x, y);
}

◆ getAddr32()

uint32_t * SkBitmap::getAddr32	(	int	x,
		int	y
	)		const

inline

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()

Parameters

x	column index, zero or greater, and less than width()
y	row index, zero or greater, and less than height()

Returns: unsigned 32-bit pointer to pixel at (x, y)

Definition at line 1260 of file SkBitmap.h.

                                                       {
    SkASSERT(fPixmap.addr());
    return fPixmap.writable_addr32(x, y);
}

◆ getAddr8()

uint8_t * SkBitmap::getAddr8	(	int	x,
		int	y
	)		const

inline

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()

Parameters

x	column index, zero or greater, and less than width()
y	row index, zero or greater, and less than height()

Returns: unsigned 8-bit pointer to pixel at (x, y)

Definition at line 1270 of file SkBitmap.h.

                                                     {
    SkASSERT(fPixmap.addr());
    return fPixmap.writable_addr8(x, y);
}

◆ getAlphaf()

float SkBitmap::getAlphaf	(	int	x,
		int	y
	)		const

inline

Look up the pixel at (x,y) and return its alpha component, normalized to [0..1]. This is roughly equivalent to SkGetColorA(getColor()), but can be more efficent (and more precise if the pixels store more than 8 bits per component).

Parameters

x	column index, zero or greater, and less than width()
y	row index, zero or greater, and less than height()

Returns: alpha converted to normalized float

Definition at line 903 of file SkBitmap.h.

                                        {
        return this->pixmap().getAlphaf(x, y);
    }

◆ getBounds() [1/2]

void SkBitmap::getBounds ( SkIRect * bounds ) const

Returns SkIRect { 0, 0, width(), height() }.

Parameters

bounds container for integral rectangle

example: https://fiddle.skia.org/c/@Bitmap_getBounds_2

Definition at line 103 of file SkBitmap.cpp.

                                              {
    SkASSERT(bounds);
    *bounds = fPixmap.bounds();
}

◆ getBounds() [2/2]

void SkBitmap::getBounds ( SkRect * bounds ) const

Returns SkRect { 0, 0, width(), height() }.

Parameters

bounds container for floating point rectangle

example: https://fiddle.skia.org/c/@Bitmap_getBounds

Definition at line 98 of file SkBitmap.cpp.

                                             {
    SkASSERT(bounds);
    *bounds = SkRect::Make(this->dimensions());
}

◆ getColor()

SkColor SkBitmap::getColor	(	int	x,
		int	y
	)		const

inline

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.

Parameters

x	column index, zero or greater, and less than width()
y	row index, zero or greater, and less than height()

Returns: pixel converted to unpremultiplied color

Definition at line 874 of file SkBitmap.h.

                                         {
        return this->pixmap().getColor(x, y);
    }

◆ getColor4f()

SkColor4f SkBitmap::getColor4f	(	int	x,
		int	y
	)		const

inline

Returns pixel at (x, y) as unpremultiplied float 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.

Parameters

x	column index, zero or greater, and less than width()
y	row index, zero or greater, and less than height()

Returns: pixel converted to unpremultiplied color

Definition at line 893 of file SkBitmap.h.

893{ return this->pixmap().getColor4f(x, y); }

SkPixmap::getColor4f

SkColor4f getColor4f(int x, int y) const

Definition: SkPixmap.cpp:388

◆ getGenerationID()

uint32_t SkBitmap::getGenerationID ( ) const

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.

Returns: unique value for pixels in SkPixelRef

example: https://fiddle.skia.org/c/@Bitmap_getGenerationID

Definition at line 361 of file SkBitmap.cpp.

                                         {
    return fPixelRef ? fPixelRef->getGenerationID() : 0;
}

◆ getPixels()

void * SkBitmap::getPixels ( ) const

inline

Returns pixel address, the base address corresponding to the pixel origin.

Returns: pixel address

Definition at line 283 of file SkBitmap.h.

283{ return fPixmap.writable_addr(); }

SkPixmap::writable_addr

void * writable_addr() const

Definition: SkPixmap.h:483

◆ getSubset()

SkIRect SkBitmap::getSubset ( ) const

inline

Returns the bounds of this bitmap, offset by its SkPixelRef origin.

Returns: bounds within SkPixelRef bounds

Definition at line 394 of file SkBitmap.h.

                              {
        SkIPoint origin = this->pixelRefOrigin();
        return SkIRect::MakeXYWH(origin.x(), origin.y(), this->width(), this->height());
    }

◆ height()

int SkBitmap::height ( ) const

inline

Returns pixel row count.

Maybe be less than pixelRef().height(). Will not exceed pixelRef().height() less pixelRefOrigin().fY.

Returns: pixel height in SkImageInfo

Definition at line 158 of file SkBitmap.h.

158{ return fPixmap.height(); }

SkPixmap::height

int height() const

Definition: SkPixmap.h:166

◆ info()

const SkImageInfo & SkBitmap::info ( ) const

inline

Returns width, height, SkAlphaType, SkColorType, and SkColorSpace.

Returns: reference to SkImageInfo

Definition at line 139 of file SkBitmap.h.

139{ return fPixmap.info(); }

◆ installMaskPixels()

bool SkBitmap::installMaskPixels ( SkMaskBuilder & mask )

Deprecated.

Definition at line 349 of file SkBitmap.cpp.

                                                    {
    if (SkMask::kA8_Format != mask.fFormat) {
        this->reset();
        return false;
    }
    return this->installPixels(SkImageInfo::MakeA8(mask.fBounds.width(),
                                                   mask.fBounds.height()),
                               mask.image(), mask.fRowBytes);
}

◆ installPixels() [1/3]

bool SkBitmap::installPixels	(	const SkImageInfo &	info,
		void *	pixels,
		size_t	rowBytes
	)

inline

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.

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace
pixels	address or pixel storage; may be nullptr
rowBytes	size of pixel row or larger

Returns: true if SkImageInfo is set to info

Definition at line 627 of file SkBitmap.h.

                                                                               {
        return this->installPixels(info, pixels, rowBytes, nullptr, nullptr);
    }

◆ installPixels() [2/3]

bool SkBitmap::installPixels	(	const SkImageInfo &	info,
		void *	pixels,
		size_t	rowBytes,
		void()(void addr, void *context)	releaseProc,
		void *	context
	)

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.

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace
pixels	address or pixel storage; may be nullptr
rowBytes	size of pixel row or larger
releaseProc	function called when pixels can be deleted; may be nullptr
context	caller state passed to releaseProc; may be nullptr

Returns: true if SkImageInfo is set to info

Definition at line 323 of file SkBitmap.cpp.

                                                                                            {
    if (!this->setInfo(requestedInfo, rb)) {
        invoke_release_proc(releaseProc, pixels, context);
        this->reset();
        return false;
    }
    if (nullptr == pixels) {
        invoke_release_proc(releaseProc, pixels, context);
        return true;    // we behaved as if they called setInfo()
    }
 
    // setInfo may have corrected info (e.g. 565 is always opaque).
    const SkImageInfo& correctedInfo = this->info();
    this->setPixelRef(
            SkMakePixelRefWithProc(correctedInfo.width(), correctedInfo.height(),
                                   rb, pixels, releaseProc, context), 0, 0);
    SkDEBUGCODE(this->validate();)
    return true;
}

◆ installPixels() [3/3]

bool SkBitmap::installPixels ( const SkPixmap & pixmap )

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.

Parameters

pixmap SkImageInfo, pixel address, and rowBytes()

Returns: true if SkImageInfo was set to pixmap.info()

example: https://fiddle.skia.org/c/@Bitmap_installPixels_3

Definition at line 344 of file SkBitmap.cpp.

                                                   {
    return this->installPixels(pixmap.info(), pixmap.writable_addr(), pixmap.rowBytes(),
                               nullptr, nullptr);
}

◆ isImmutable()

bool SkBitmap::isImmutable ( ) const

Returns true if pixels can not change.

Most immutable SkBitmap checks trigger an assert only on debug builds.

Returns: true if pixels are immutable

example: https://fiddle.skia.org/c/@Bitmap_isImmutable

Definition at line 396 of file SkBitmap.cpp.

                                 {
    return fPixelRef ? fPixelRef->isImmutable() : false;
}

◆ isNull()

bool SkBitmap::isNull ( ) const

inline

Returns true if SkPixelRef is nullptr.

Does not check if width() or height() are zero; call drawsNothing() to check width(), height(), and SkPixelRef.

Returns: true if no SkPixelRef is associated

Definition at line 219 of file SkBitmap.h.

219{ return nullptr == fPixelRef; }

◆ isOpaque()

bool SkBitmap::isOpaque ( ) const

inline

Returns true if SkAlphaType is set to hint that all pixels are opaque; their alpha value is implicitly or explicitly 1.0. If true, and all pixels are not opaque, Skia may draw incorrectly.

Does not check if SkColorType allows alpha, or if any pixel value has transparency.

Returns: true if SkImageInfo SkAlphaType is kOpaque_SkAlphaType

Definition at line 324 of file SkBitmap.h.

                          {
        return SkAlphaTypeIsOpaque(this->alphaType());
    }

◆ makeShader() [1/4]

sk_sp< SkShader > SkBitmap::makeShader	(	const SkSamplingOptions &	sampling,
		const SkMatrix &	lm
	)		const

Defaults to clamp in both X and Y.

Definition at line 647 of file SkBitmap.cpp.

                                                               {
    return this->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
                            sampling, &lm);
}

◆ makeShader() [2/4]

sk_sp< SkShader > SkBitmap::makeShader	(	const SkSamplingOptions &	sampling,
		const SkMatrix *	lm = `nullptr`
	)		const

Definition at line 653 of file SkBitmap.cpp.

                                                               {
    return this->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
                            sampling, lm);
}

◆ makeShader() [3/4]

sk_sp< SkShader > SkBitmap::makeShader	(	SkTileMode	tmx,
		SkTileMode	tmy,
		const SkSamplingOptions &	sampling,
		const SkMatrix *	localMatrix = `nullptr`
	)		const

Make a shader with the specified tiling, matrix and sampling.

Definition at line 669 of file SkBitmap.cpp.

                                                               {
    if (lm && !lm->invert(nullptr)) {
        return nullptr;
    }
    return SkImageShader::Make(SkMakeImageFromRasterBitmap(*this, kIfMutable_SkCopyPixelsMode),
                               tmx, tmy, sampling, lm);
}

◆ makeShader() [4/4]

sk_sp< SkShader > SkBitmap::makeShader	(	SkTileMode	tmx,
		SkTileMode	tmy,
		const SkSamplingOptions &	sampling,
		const SkMatrix &	lm
	)		const

Definition at line 659 of file SkBitmap.cpp.

                                                               {
    if (!lm.invert(nullptr)) {
        return nullptr;
    }
    return SkImageShader::Make(SkMakeImageFromRasterBitmap(*this, kIfMutable_SkCopyPixelsMode),
                               tmx, tmy, sampling, &lm);
}

◆ notifyPixelsChanged()

void SkBitmap::notifyPixelsChanged ( ) const

Marks that pixels in SkPixelRef have changed. Subsequent calls to getGenerationID() return a different value.

example: https://fiddle.skia.org/c/@Bitmap_notifyPixelsChanged

Definition at line 365 of file SkBitmap.cpp.

                                         {
    SkASSERT(!this->isImmutable());
    if (fPixelRef) {
        fPixelRef->notifyPixelsChanged();
    }
}

◆ operator=() [1/2]

SkBitmap & SkBitmap::operator= ( const SkBitmap & src )

Copies settings from src to returned SkBitmap. Shares pixels if src has pixels allocated, so both bitmaps reference the same pixels.

Parameters

src	SkBitmap to copy SkImageInfo, and share SkPixelRef

Returns: copy of src

example: https://fiddle.skia.org/c/@Bitmap_copy_operator

Definition at line 65 of file SkBitmap.cpp.

                                                 {
    if (this != &src) {
        fPixelRef       = src.fPixelRef;
        fPixmap         = src.fPixmap;
        fMips           = src.fMips;
    }
    SkDEBUGCODE(this->validate();)
    return *this;
}

◆ operator=() [2/2]

SkBitmap & SkBitmap::operator= ( SkBitmap && src )

Copies settings from src to returned SkBitmap. Moves ownership of src pixels to SkBitmap.

Parameters

src	SkBitmap to copy SkImageInfo, and reassign SkPixelRef

Returns: copy of src

example: https://fiddle.skia.org/c/@Bitmap_move_operator

Definition at line 75 of file SkBitmap.cpp.

                                              {
    if (this != &other) {
        fPixelRef       = std::move(other.fPixelRef);
        fPixmap         = std::move(other.fPixmap);
        fMips           = std::move(other.fMips);
        SkASSERT(!other.fPixelRef);
        other.fPixmap.reset();
    }
    return *this;
}

◆ peekPixels()

bool SkBitmap::peekPixels ( SkPixmap * pixmap ) 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.

Parameters

pixmap storage for pixel state if pixels are readable; otherwise, ignored

Returns: true if SkBitmap has direct access to pixels

example: https://fiddle.skia.org/c/@Bitmap_peekPixels

Definition at line 635 of file SkBitmap.cpp.

                                              {
    if (this->getPixels()) {
        if (pmap) {
            *pmap = fPixmap;
        }
        return true;
    }
    return false;
}

◆ pixelRef()

SkPixelRef * SkBitmap::pixelRef ( ) const

inline

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.

Returns: SkPixelRef, or nullptr

Definition at line 720 of file SkBitmap.h.

720{ return fPixelRef.get(); }

sk_sp::get

T * get() const

Definition: SkRefCnt.h:303

◆ pixelRefOrigin()

SkIPoint SkBitmap::pixelRefOrigin ( ) const

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.

Returns: pixel origin within SkPixelRef

example: https://fiddle.skia.org/c/@Bitmap_pixelRefOrigin

Definition at line 168 of file SkBitmap.cpp.

                                        {
    const char* addr = (const char*)fPixmap.addr();
    const char* pix = (const char*)(fPixelRef ? fPixelRef->pixels() : nullptr);
    size_t rb = this->rowBytes();
    if (!pix || 0 == rb) {
        return {0, 0};
    }
    SkASSERT(this->bytesPerPixel() > 0);
    SkASSERT(this->bytesPerPixel() == (1 << this->shiftPerPixel()));
    SkASSERT(addr >= pix);
    size_t off = addr - pix;
    return {SkToS32((off % rb) >> this->shiftPerPixel()), SkToS32(off / rb)};
}

◆ pixmap()

const SkPixmap & SkBitmap::pixmap ( ) const

inline

Returns a constant reference to the SkPixmap holding the SkBitmap pixel address, row bytes, and SkImageInfo.

Returns: reference to SkPixmap describing this SkBitmap

Definition at line 133 of file SkBitmap.h.

133{ return fPixmap; }

◆ readPixels() [1/3]

bool SkBitmap::readPixels	(	const SkImageInfo &	dstInfo,
		void *	dstPixels,
		size_t	dstRowBytes,
		int	srcX,
		int	srcY
	)		const

Copies a SkRect of pixels from SkBitmap to dstPixels. Copy starts at (srcX, srcY), and does not exceed SkBitmap (width(), 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 has no address
dstRowBytes is less than dstInfo.minRowBytes()
SkPixelRef is nullptr

Pixels are copied only if pixel conversion is possible. If SkBitmap colorType() is kGray_8_SkColorType, or kAlpha_8_SkColorType; dstInfo.colorType() must match. If SkBitmap colorType() is kGray_8_SkColorType, dstInfo.colorSpace() must match. If SkBitmap alphaType() is kOpaque_SkAlphaType, dstInfo.alphaType() must match. If SkBitmap 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) >= Bitmap width(), or if abs(srcY) >= Bitmap height().

Parameters

dstInfo	destination width, height, SkColorType, SkAlphaType, SkColorSpace
dstPixels	destination pixel storage
dstRowBytes	destination row length
srcX	column index whose absolute value is less than width()
srcY	row index whose absolute value is less than height()

Returns: true if pixels are copied to dstPixels

Definition at line 488 of file SkBitmap.cpp.

                                              {
    SkPixmap src;
    if (!this->peekPixels(&src)) {
        return false;
    }
    return src.readPixels(requestedDstInfo, dstPixels, dstRB, x, y);
}

◆ readPixels() [2/3]

bool SkBitmap::readPixels ( const SkPixmap & dst ) const

inline

Copies a SkRect of pixels from SkBitmap to dst. Copy starts at (0, 0), and does not exceed SkBitmap (width(), 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 SkBitmap colorType() is kGray_8_SkColorType, or kAlpha_8_SkColorType; dst SkColorType must match. If SkBitmap colorType() is kGray_8_SkColorType, dst SkColorSpace must match. If SkBitmap alphaType() is kOpaque_SkAlphaType, dst SkAlphaType must match. If SkBitmap colorSpace() is nullptr, dst SkColorSpace must match. Returns false if pixel conversion is not possible.

Parameters

dst	destination SkPixmap: SkImageInfo, pixels, row bytes

Returns: true if pixels are copied to dst

Definition at line 1068 of file SkBitmap.h.

                                               {
        return this->readPixels(dst, 0, 0);
    }

◆ readPixels() [3/3]

bool SkBitmap::readPixels	(	const SkPixmap &	dst,
		int	srcX,
		int	srcY
	)		const

Copies a SkRect of pixels from SkBitmap to dst. Copy starts at (srcX, srcY), and does not exceed SkBitmap (width(), 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 SkBitmap colorType() is kGray_8_SkColorType, or kAlpha_8_SkColorType; dst SkColorType must match. If SkBitmap colorType() is kGray_8_SkColorType, dst SkColorSpace must match. If SkBitmap alphaType() is kOpaque_SkAlphaType, dst SkAlphaType must match. If SkBitmap 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) >= Bitmap width(), or if abs(srcY) >= Bitmap height().

Parameters

dst	destination SkPixmap: SkImageInfo, pixels, row bytes
srcX	column index whose absolute value is less than width()
srcY	row index whose absolute value is less than height()

Returns: true if pixels are copied to dst

example: https://fiddle.skia.org/c/@Bitmap_readPixels_2

Definition at line 497 of file SkBitmap.cpp.

                                                                       {
    return this->readPixels(dst.info(), dst.writable_addr(), dst.rowBytes(), srcX, srcY);
}

◆ readyToDraw()

bool SkBitmap::readyToDraw ( ) const

inline

Returns true if SkBitmap is can be drawn.

Returns: true if getPixels() is not nullptr

Definition at line 758 of file SkBitmap.h.

                             {
        return this->getPixels() != nullptr;
    }

◆ refColorSpace()

sk_sp< SkColorSpace > SkBitmap::refColorSpace ( ) const

Returns 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.

Returns: SkColorSpace in SkImageInfo wrapped in a smart pointer

Definition at line 110 of file SkBitmap.cpp.

110{ return fPixmap.info().refColorSpace(); }

SkImageInfo::refColorSpace

sk_sp< SkColorSpace > refColorSpace() const

Definition: SkImageInfo.cpp:121

◆ reset()

void SkBitmap::reset ( )

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.

example: https://fiddle.skia.org/c/@Bitmap_reset

Definition at line 92 of file SkBitmap.cpp.

                     {
    fPixelRef = nullptr;  // Free pixels.
    fPixmap.reset();
    fMips.reset();
}

◆ rowBytes()

size_t SkBitmap::rowBytes ( ) const

inline

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.

Returns: byte length of pixel row

Definition at line 238 of file SkBitmap.h.

238{ return fPixmap.rowBytes(); }

◆ rowBytesAsPixels()

int SkBitmap::rowBytesAsPixels ( ) const

inline

Returns number of pixels that fit on row. Should be greater than or equal to width().

Returns: maximum pixels per row

Definition at line 194 of file SkBitmap.h.

194{ return fPixmap.rowBytesAsPixels(); }

SkPixmap::rowBytesAsPixels

int rowBytesAsPixels() const

Definition: SkPixmap.h:214

◆ setAlphaType()

bool SkBitmap::setAlphaType ( SkAlphaType alphaType )

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.

Returns: true if SkAlphaType is set

example: https://fiddle.skia.org/c/@Bitmap_setAlphaType

Definition at line 148 of file SkBitmap.cpp.

                                                    {
    if (!SkColorTypeValidateAlphaType(this->colorType(), newAlphaType, &newAlphaType)) {
        return false;
    }
    if (this->alphaType() != newAlphaType) {
        auto newInfo = fPixmap.info().makeAlphaType(newAlphaType);
        fPixmap.reset(std::move(newInfo), fPixmap.addr(), fPixmap.rowBytes());
    }
    SkDEBUGCODE(this->validate();)
    return true;
}

◆ setColorSpace()

void SkBitmap::setColorSpace ( sk_sp< SkColorSpace > colorSpace )

Sets the SkColorSpace associated with this SkBitmap.

The raw pixel data is not altered by this call; no conversion is performed.

This changes SkColorSpace in SkPixelRef; all bitmaps sharing SkPixelRef are affected.

Definition at line 160 of file SkBitmap.cpp.

                                                              {
    if (this->colorSpace() != newColorSpace.get()) {
        SkImageInfo newInfo = fPixmap.info().makeColorSpace(std::move(newColorSpace));
        fPixmap.reset(std::move(newInfo), fPixmap.addr(), fPixmap.rowBytes());
    }
    SkDEBUGCODE(this->validate();)
}

◆ setImmutable()

void SkBitmap::setImmutable ( )

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.

example: https://fiddle.skia.org/c/@Bitmap_setImmutable

Definition at line 400 of file SkBitmap.cpp.

                            {
    if (fPixelRef) {
        fPixelRef->setImmutable();
    }
}

◆ setInfo()

bool SkBitmap::setInfo	(	const SkImageInfo &	imageInfo,
		size_t	rowBytes = `0`
	)

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() is negative
imageInfo.height() is negative
rowBytes is positive and less than imageInfo.width() times imageInfo.bytesPerPixel()

Parameters

imageInfo	contains width, height, SkAlphaType, SkColorType, SkColorSpace
rowBytes	imageInfo.minRowBytes() or larger; or zero

Returns: true if SkImageInfo set successfully

example: https://fiddle.skia.org/c/@Bitmap_setInfo

Definition at line 114 of file SkBitmap.cpp.

                                                               {
    SkAlphaType newAT = info.alphaType();
    if (!SkColorTypeValidateAlphaType(info.colorType(), info.alphaType(), &newAT)) {
        return reset_return_false(this);
    }
    // don't look at info.alphaType(), since newAT is the real value...
 
    // require that rowBytes fit in 31bits
    int64_t mrb = info.minRowBytes64();
    if (!SkTFitsIn<int32_t>(mrb)) {
        return reset_return_false(this);
    }
    if (!SkTFitsIn<int32_t>(rowBytes)) {
        return reset_return_false(this);
    }
 
    if (info.width() < 0 || info.height() < 0) {
        return reset_return_false(this);
    }
 
    if (kUnknown_SkColorType == info.colorType()) {
        rowBytes = 0;
    } else if (0 == rowBytes) {
        rowBytes = (size_t)mrb;
    } else if (!info.validRowBytes(rowBytes)) {
        return reset_return_false(this);
    }
 
    fPixelRef = nullptr;  // Free pixels.
    fPixmap.reset(info.makeAlphaType(newAT), nullptr, SkToU32(rowBytes));
    SkDEBUGCODE(this->validate();)
    return true;
}

◆ setPixelRef()

void SkBitmap::setPixelRef	(	sk_sp< SkPixelRef >	pixelRef,
		int	dx,
		int	dy
	)

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.

Parameters

pixelRef	SkPixelRef describing pixel address and rowBytes()
dx	column offset in SkPixelRef for bitmap origin
dy	row offset in SkPixelRef for bitmap origin

example: https://fiddle.skia.org/c/@Bitmap_setPixelRef

Definition at line 182 of file SkBitmap.cpp.

                                                               {
#ifdef SK_DEBUG
    if (pr) {
        if (kUnknown_SkColorType != this->colorType()) {
            SkASSERT(dx >= 0 && this->width() + dx <= pr->width());
            SkASSERT(dy >= 0 && this->height() + dy <= pr->height());
        }
    }
#endif
    fPixelRef = kUnknown_SkColorType != this->colorType() ? std::move(pr) : nullptr;
    void* p = nullptr;
    size_t rowBytes = this->rowBytes();
    // ignore dx,dy if there is no pixelref
    if (fPixelRef) {
        rowBytes = fPixelRef->rowBytes();
        // TODO(reed):  Enforce that PixelRefs must have non-null pixels.
        p = fPixelRef->pixels();
        if (p) {
            p = (char*)p + dy * rowBytes + dx * this->bytesPerPixel();
        }
    }
    fPixmap.reset(fPixmap.info(), p, rowBytes);
    SkDEBUGCODE(this->validate();)
}

◆ setPixels()

void SkBitmap::setPixels ( void * pixels )

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.

Parameters

pixels address of pixel storage, managed by caller

example: https://fiddle.skia.org/c/@Bitmap_setPixels

Definition at line 207 of file SkBitmap.cpp.

                                {
    if (kUnknown_SkColorType == this->colorType()) {
        p = nullptr;
    }
    size_t rb = this->rowBytes();
    fPixmap.reset(fPixmap.info(), p, rb);
    fPixelRef = p ? sk_make_sp<SkPixelRef>(this->width(), this->height(), p, rb) : nullptr;
    SkDEBUGCODE(this->validate();)
}

◆ shiftPerPixel()

int SkBitmap::shiftPerPixel ( ) const

inline

Returns bit shift converting row bytes to row pixels. Returns zero for kUnknown_SkColorType.

Returns: one of: 0, 1, 2, 3; left shift to convert pixels to bytes

Definition at line 201 of file SkBitmap.h.

201{ return fPixmap.shiftPerPixel(); }

SkPixmap::shiftPerPixel

int shiftPerPixel() const

Definition: SkPixmap.h:221

◆ swap()

void SkBitmap::swap ( SkBitmap & other )

Swaps the fields of the two bitmaps.

Parameters

other SkBitmap exchanged with original

example: https://fiddle.skia.org/c/@Bitmap_swap

Definition at line 86 of file SkBitmap.cpp.

                                   {
    using std::swap;
    swap(*this, other);
    SkDEBUGCODE(this->validate();)
}

◆ tryAllocN32Pixels()

bool SkBitmap::tryAllocN32Pixels	(	int	width,
		int	height,
		bool	isOpaque = `false`
	)

Sets SkImageInfo to width, height, and native color type; 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 SkPMColor, the native pixel arrangement on the platform. SkBitmap drawn to output device skips converting its pixel format.

Parameters

width	pixel column count; must be zero or greater
height	pixel row count; must be zero or greater
isOpaque	true if pixels do not have transparency

Returns: true if pixel storage is allocated

Definition at line 226 of file SkBitmap.cpp.

                                                                     {
    SkImageInfo info = SkImageInfo::MakeN32(width, height,
            isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
    return this->tryAllocPixels(info);
}

◆ tryAllocPixels() [1/4]

bool SkBitmap::tryAllocPixels ( )

inline

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 fails.

Returns: true if the allocation succeeds

Definition at line 674 of file SkBitmap.h.

                                        {
        return this->tryAllocPixels((Allocator*)nullptr);
    }

◆ tryAllocPixels() [2/4]

bool SkBitmap::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.

Returns false if Allocator::allocPixelRef return false.

Parameters

allocator instance of SkBitmap::Allocator instantiation

Returns: true if custom allocator reports success

Definition at line 217 of file SkBitmap.cpp.

                                                  {
    HeapAllocator stdalloc;
 
    if (nullptr == allocator) {
        allocator = &stdalloc;
    }
    return allocator->allocPixelRef(this);
}

◆ tryAllocPixels() [3/4]

bool SkBitmap::tryAllocPixels ( const SkImageInfo & info )

inline

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().

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace

Returns: true if pixel storage is allocated

Definition at line 527 of file SkBitmap.h.

                                                               {
        return this->tryAllocPixels(info, info.minRowBytes());
    }

◆ tryAllocPixels() [4/4]

bool SkBitmap::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.

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().

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace
rowBytes	size of pixel row or larger; may be zero

Returns: true if pixel storage is allocated

Definition at line 271 of file SkBitmap.cpp.

                                                                               {
    if (!this->setInfo(requestedInfo, rowBytes)) {
        return reset_return_false(this);
    }
 
    // setInfo may have corrected info (e.g. 565 is always opaque).
    const SkImageInfo& correctedInfo = this->info();
    if (kUnknown_SkColorType == correctedInfo.colorType()) {
        return true;
    }
    // setInfo may have computed a valid rowbytes if 0 were passed in
    rowBytes = this->rowBytes();
 
    sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(correctedInfo, rowBytes);
    if (!pr) {
        return reset_return_false(this);
    }
    this->setPixelRef(std::move(pr), 0, 0);
    if (nullptr == this->getPixels()) {
        return reset_return_false(this);
    }
    SkDEBUGCODE(this->validate();)
    return true;
}

◆ tryAllocPixelsFlags()

bool SkBitmap::tryAllocPixelsFlags	(	const SkImageInfo &	info,
		uint32_t	flags
	)

Sets SkImageInfo to info following the rules in setInfo() and allocates pixel memory. Memory is zeroed.

Returns false and calls reset() if SkImageInfo could not be set, or memory could not be allocated, 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 calloc().

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace
flags	kZeroPixels_AllocFlag, or zero

Returns: true if pixels allocation is successful

Definition at line 296 of file SkBitmap.cpp.

                                                                                        {
    if (!this->setInfo(requestedInfo)) {
        return reset_return_false(this);
    }
 
    // setInfo may have corrected info (e.g. 565 is always opaque).
    const SkImageInfo& correctedInfo = this->info();
 
    sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(correctedInfo,
                                                          correctedInfo.minRowBytes());
    if (!pr) {
        return reset_return_false(this);
    }
    this->setPixelRef(std::move(pr), 0, 0);
    if (nullptr == this->getPixels()) {
        return reset_return_false(this);
    }
    SkDEBUGCODE(this->validate();)
    return true;
}

◆ width()

int SkBitmap::width ( ) const

inline

Returns pixel count in each row. Should be equal or less than rowBytes() / info().bytesPerPixel().

May be less than pixelRef().width(). Will not exceed pixelRef().width() less pixelRefOrigin().fX.

Returns: pixel width in SkImageInfo

Definition at line 149 of file SkBitmap.h.

149{ return fPixmap.width(); }

SkPixmap::width

int width() const

Definition: SkPixmap.h:160

◆ writePixels() [1/2]

bool SkBitmap::writePixels ( const SkPixmap & src )

inline

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 SkBitmap colorType() is kGray_8_SkColorType, or kAlpha_8_SkColorType; src SkColorType must match. If SkBitmap colorType() is kGray_8_SkColorType, src SkColorSpace must match. If SkBitmap alphaType() is kOpaque_SkAlphaType, src SkAlphaType must match. If SkBitmap colorSpace() is nullptr, src SkColorSpace must match. Returns false if pixel conversion is not possible.

Parameters

src	source SkPixmap: SkImageInfo, pixels, row bytes

Returns: true if src pixels are copied to SkBitmap

Definition at line 1122 of file SkBitmap.h.

                                          {
        return this->writePixels(src, 0, 0);
    }

◆ writePixels() [2/2]

bool SkBitmap::writePixels	(	const SkPixmap &	src,
		int	dstX,
		int	dstY
	)

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 SkBitmap colorType() is kGray_8_SkColorType, or kAlpha_8_SkColorType; src SkColorType must match. If SkBitmap colorType() is kGray_8_SkColorType, src SkColorSpace must match. If SkBitmap alphaType() is kOpaque_SkAlphaType, src SkAlphaType must match. If SkBitmap 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) >= Bitmap width(), or if abs(dstY) >= Bitmap height().

Parameters

src	source SkPixmap: SkImageInfo, pixels, row bytes
dstX	column index whose absolute value is less than width()
dstY	row index whose absolute value is less than height()

Returns: true if src pixels are copied to SkBitmap

example: https://fiddle.skia.org/c/@Bitmap_writePixels

Definition at line 501 of file SkBitmap.cpp.

                                                                  {
    if (!SkImageInfoValidConversion(this->info(), src.info())) {
        return false;
    }
 
    SkWritePixelsRec rec(src.info(), src.addr(), src.rowBytes(), dstX, dstY);
    if (!rec.trim(this->width(), this->height())) {
        return false;
    }
 
    void* dstPixels = this->getAddr(rec.fX, rec.fY);
    const SkImageInfo dstInfo = this->info().makeDimensions(rec.fInfo.dimensions());
    if (!SkConvertPixels(dstInfo,     dstPixels, this->rowBytes(),
                         rec.fInfo, rec.fPixels,   rec.fRowBytes)) {
        return false;
    }
    this->notifyPixelsChanged();
    return true;
}

Friends And Related Function Documentation

◆ GrProxyProvider

friend class GrProxyProvider

friend

Definition at line 1255 of file SkBitmap.h.

◆ SkImage_Raster

friend class SkImage_Raster

friend

Definition at line 1253 of file SkBitmap.h.

◆ SkReadBuffer

friend class SkReadBuffer

friend

Definition at line 1254 of file SkBitmap.h.

Member Data Documentation

◆ Allocator

class SK_API SkBitmap::Allocator

Definition at line 61 of file SkBitmap.h.

The documentation for this class was generated from the following files:

third_party/skia/include/core/SkBitmap.h
third_party/skia/src/core/SkBitmap.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ AllocFlags

Constructor & Destructor Documentation

◆ SkBitmap() [1/3]

◆ SkBitmap() [2/3]

◆ SkBitmap() [3/3]

◆ ~SkBitmap()

Member Function Documentation

◆ allocN32Pixels()

◆ allocPixels() [1/4]

◆ allocPixels() [2/4]

◆ allocPixels() [3/4]

◆ allocPixels() [4/4]

◆ allocPixelsFlags()

◆ alphaType()

◆ asImage()

◆ bounds()

◆ bytesPerPixel()

◆ colorSpace()

◆ colorType()

◆ computeByteSize()

◆ ComputeIsOpaque()

◆ dimensions()

◆ drawsNothing()

◆ empty()

◆ erase() [1/2]

◆ erase() [2/2]

◆ eraseArea()

◆ eraseARGB()

◆ eraseColor() [1/2]

◆ eraseColor() [2/2]

◆ extractAlpha() [1/3]

◆ extractAlpha() [2/3]

◆ extractAlpha() [3/3]

◆ extractSubset()

◆ getAddr()

◆ getAddr16()

◆ getAddr32()

◆ getAddr8()

◆ getAlphaf()

◆ getBounds() [1/2]

◆ getBounds() [2/2]

◆ getColor()

◆ getColor4f()

◆ getGenerationID()

◆ getPixels()

◆ getSubset()

◆ height()

◆ info()

◆ installMaskPixels()

◆ installPixels() [1/3]

◆ installPixels() [2/3]

◆ installPixels() [3/3]

◆ isImmutable()

◆ isNull()

◆ isOpaque()

◆ makeShader() [1/4]

◆ makeShader() [2/4]

◆ makeShader() [3/4]

◆ makeShader() [4/4]

◆ notifyPixelsChanged()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ peekPixels()

◆ pixelRef()

◆ pixelRefOrigin()

◆ pixmap()

◆ readPixels() [1/3]

◆ readPixels() [2/3]

◆ readPixels() [3/3]

◆ readyToDraw()

◆ refColorSpace()

◆ reset()