SkMaskBuilder Struct Reference

#include <SkMask.h>

Inheritance diagram for SkMaskBuilder:

Public Types
enum	AllocType { kUninit_Alloc , kZeroInit_Alloc }
enum	CreateMode { kJustComputeBounds_CreateMode , kJustRenderImage_CreateMode , kComputeBoundsAndRenderImage_CreateMode }
Public Types inherited from SkMask
enum	Format : uint8_t {   kBW_Format , kA8_Format , k3D_Format , kARGB32_Format ,   kLCD16_Format , kSDF_Format }
enum	{ kCountMaskFormats = kSDF_Format + 1 }

Public Member Functions
	SkMaskBuilder ()
	SkMaskBuilder (const SkMaskBuilder &)=delete
	SkMaskBuilder (SkMaskBuilder &&)=default
SkMaskBuilder &	operator= (const SkMaskBuilder &)=delete
SkMaskBuilder &	operator= (SkMaskBuilder &&that)
	SkMaskBuilder (uint8_t *img, const SkIRect &bounds, uint32_t rowBytes, Format format)
uint8_t *&	image ()
SkIRect &	bounds ()
uint32_t &	rowBytes ()
Format &	format ()
uint8_t *	getAddr1 (int x, int y)
uint8_t *	getAddr8 (int x, int y)
uint16_t *	getAddrLCD16 (int x, int y)
uint32_t *	getAddr32 (int x, int y)
void *	getAddr (int x, int y)
Public Member Functions inherited from SkMask
	SkMask (const uint8_t *img, const SkIRect &bounds, uint32_t rowBytes, Format format)
bool	isEmpty () const
size_t	computeImageSize () const
size_t	computeTotalImageSize () const
const uint8_t *	getAddr1 (int x, int y) const
const uint8_t *	getAddr8 (int x, int y) const
const uint16_t *	getAddrLCD16 (int x, int y) const
const uint32_t *	getAddr32 (int x, int y) const
const void *	getAddr (int x, int y) const

Static Public Member Functions
static uint8_t *	AllocImage (size_t bytes, AllocType=kUninit_Alloc)
static void	FreeImage (void *image)
static SkMaskBuilder	PrepareDestination (int radiusX, int radiusY, const SkMask &src)
Static Public Member Functions inherited from SkMask
static bool	IsValidFormat (uint8_t format)

Additional Inherited Members
Public Attributes inherited from SkMask
uint8_t const *const	fImage
const SkIRect	fBounds
const uint32_t	fRowBytes
const Format	fFormat

Detailed Description

Definition at line 219 of file SkMask.h.

Member Enumeration Documentation

AllocType

enum SkMaskBuilder::AllocType

Enumerator
kUninit_Alloc
kZeroInit_Alloc

Definition at line 291 of file SkMask.h.

                   {
        kUninit_Alloc,
        kZeroInit_Alloc,
    };

CreateMode

enum SkMaskBuilder::CreateMode

Enumerator
kJustComputeBounds_CreateMode	compute bounds and return
kJustRenderImage_CreateMode	render into preallocate mask
kComputeBoundsAndRenderImage_CreateMode	compute bounds, alloc image and render into it

Definition at line 298 of file SkMask.h.

                    {
        kJustComputeBounds_CreateMode,      //!< compute bounds and return
        kJustRenderImage_CreateMode,        //!< render into preallocate mask
        kComputeBoundsAndRenderImage_CreateMode  //!< compute bounds, alloc image and render into it
    };

Constructor & Destructor Documentation

SkMaskBuilder() [1/4]

SkMaskBuilder::SkMaskBuilder ( )

inline

Definition at line 220 of file SkMask.h.

: SkMask(nullptr, {0}, 0, SkMask::Format::kBW_Format) {}

SkMaskBuilder() [2/4]

SkMaskBuilder::SkMaskBuilder ( const SkMaskBuilder &  )

delete

SkMaskBuilder() [3/4]

SkMaskBuilder::SkMaskBuilder ( SkMaskBuilder &&  )

default

SkMaskBuilder() [4/4]

SkMaskBuilder::SkMaskBuilder ( uint8_t *  img, const SkIRect &  bounds, uint32_t  rowBytes, Format  format  )

inline

Definition at line 233 of file SkMask.h.

        : SkMask(img, bounds, rowBytes, format) {}

Member Function Documentation

AllocImage()

uint8_t * SkMaskBuilder::AllocImage ( size_t  size, AllocType  at = kUninit_Alloc  )

static

We explicitly use this allocator for SkBimap pixels, so that we can freely assign memory allocated by one class to the other.

Definition at line 45 of file SkMask.cpp.

                                                            {
    size_t aligned_size = SkSafeMath::Align4(size);
    unsigned flags = SK_MALLOC_THROW;
    if (at == kZeroInit_Alloc) {
        flags |= SK_MALLOC_ZERO_INITIALIZE;
    }
    return static_cast<uint8_t*>(sk_malloc_flags(aligned_size, flags));
}

bounds()

SkIRect & SkMaskBuilder::bounds ( )

inline

Definition at line 237 of file SkMask.h.

{ return *const_cast<SkIRect*>(&fBounds); }

format()

Format & SkMaskBuilder::format ( )

inline

Definition at line 239 of file SkMask.h.

{ return *const_cast<Format*>(&fFormat); }

FreeImage()

void SkMaskBuilder::FreeImage ( void *  image )

static

We explicitly use this allocator for SkBimap pixels, so that we can freely assign memory allocated by one class to the other.

Definition at line 57 of file SkMask.cpp.

                                         {
    sk_free(image);
}

getAddr()

void * SkMaskBuilder::getAddr ( int  x, int  y  )

inline

Returns the address of the specified pixel, computing the pixel-size at runtime based on the mask format. This will be slightly slower than using one of the routines where the format is implied by the name e.g. getAddr8 or getAddr32.

x,y must be contained by the mask's bounds (this is asserted in the debug build, but not checked in the release build.)

This should not be called with kBW_Format, as it will give unspecified results (and assert in the debug build).

Definition at line 287 of file SkMask.h.

                                {
        return const_cast<void*>(this->SkMask::getAddr(x, y));
    }

getAddr1()

uint8_t * SkMaskBuilder::getAddr1 ( int  x, int  y  )

inline

Returns the address of the byte that holds the specified bit. Asserts that the mask is kBW_Format, and that x,y are in range. x,y are in the same coordiate space as fBounds.

Definition at line 245 of file SkMask.h.

                                    {
        return const_cast<uint8_t*>(this->SkMask::getAddr1(x, y));
    }

getAddr32()

uint32_t * SkMaskBuilder::getAddr32 ( int  x, int  y  )

inline

Return the address of the specified 32bit mask. In the debug build, this asserts that the mask's format is 32bits, and that (x,y) are contained in the mask's fBounds.

Definition at line 271 of file SkMask.h.

                                      {
        return const_cast<uint32_t*>(this->SkMask::getAddr32(x, y));
    }

getAddr8()

uint8_t * SkMaskBuilder::getAddr8 ( int  x, int  y  )

inline

Returns the address of the specified byte. Asserts that the mask is kA8_Format, and that x,y are in range. x,y are in the same coordiate space as fBounds.

Definition at line 253 of file SkMask.h.

                                    {
        return const_cast<uint8_t*>(this->SkMask::getAddr8(x, y));
    }

getAddrLCD16()

uint16_t * SkMaskBuilder::getAddrLCD16 ( int  x, int  y  )

inline

Return the address of the specified 16bit mask. In the debug build, this asserts that the mask's format is kLCD16_Format, and that (x,y) are contained in the mask's fBounds.

Definition at line 262 of file SkMask.h.

                                         {
        return const_cast<uint16_t*>(this->SkMask::getAddrLCD16(x, y));
    }

image()

uint8_t *& SkMaskBuilder::image ( )

inline

Definition at line 236 of file SkMask.h.

{ return *const_cast<uint8_t**>(&fImage); }

operator=() [1/2]

SkMaskBuilder & SkMaskBuilder::operator= ( const SkMaskBuilder &  )

delete

operator=() [2/2]

SkMaskBuilder & SkMaskBuilder::operator= ( SkMaskBuilder &&  that )

inline

Definition at line 224 of file SkMask.h.

                                                   {
        this->image() = that.image();
        this->bounds() = that.bounds();
        this->rowBytes() = that.rowBytes();
        this->format() = that.format();
        that.image() = nullptr;
        return *this;
    }

PrepareDestination()

SkMaskBuilder SkMaskBuilder::PrepareDestination ( int  radiusX, int  radiusY, const SkMask &  src  )

static

Returns initial destination mask data padded by radiusX and radiusY

Definition at line 61 of file SkMask.cpp.

                                                                                           {
    SkSafeMath safe;
 
    SkMaskBuilder dst;
    dst.image() = nullptr;
    dst.format() = SkMask::kA8_Format;
 
    // dstW = srcW + 2 * radiusX;
    size_t dstW = safe.add(src.fBounds.width(), safe.add(radiusX, radiusX));
    // dstH = srcH + 2 * radiusY;
    size_t dstH = safe.add(src.fBounds.height(), safe.add(radiusY, radiusY));
 
    size_t toAlloc = safe.mul(dstW, dstH);
 
    // We can only deal with masks that fit in INT_MAX and sides that fit in int.
    if (!SkTFitsIn<int>(dstW) || !SkTFitsIn<int>(dstH) || toAlloc > INT_MAX || !safe) {
        dst.bounds().setEmpty();
        dst.rowBytes() = 0;
        return dst;
    }
 
    dst.bounds().setWH(SkTo<int>(dstW), SkTo<int>(dstH));
    dst.bounds().offset(src.fBounds.x(), src.fBounds.y());
    dst.bounds().offset(-radiusX, -radiusY);
    dst.rowBytes() = SkTo<uint32_t>(dstW);
 
    if (src.fImage != nullptr) {
        dst.image() = SkMaskBuilder::AllocImage(toAlloc);
    }
 
    return dst;
}

rowBytes()

uint32_t & SkMaskBuilder::rowBytes ( )

inline

Definition at line 238 of file SkMask.h.

{ return *const_cast<uint32_t*>(&fRowBytes); }

---

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

• third_party/skia/src/core/SkMask.h
• third_party/skia/src/core/SkMask.cpp