SkMask Class Reference

#include <SkMask.h>

Inheritance diagram for SkMask:

Classes
struct	AlphaIter
struct	AlphaIter< SkMask::kA8_Format >
struct	AlphaIter< SkMask::kARGB32_Format >
struct	AlphaIter< SkMask::kBW_Format >
struct	AlphaIter< SkMask::kLCD16_Format >

Public Types
enum	Format : uint8_t {   kBW_Format , kA8_Format , k3D_Format , kARGB32_Format ,   kLCD16_Format , kSDF_Format }
enum	{ kCountMaskFormats = kSDF_Format + 1 }

Public Member Functions
	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 bool	IsValidFormat (uint8_t format)

Public Attributes
uint8_t const *const	fImage
const SkIRect	fBounds
const uint32_t	fRowBytes
const Format	fFormat

Detailed Description

SkMask is used to describe alpha bitmaps, either 1bit, 8bit, or the 3-channel 3D format. These are passed to SkMaskFilter objects.

Definition at line 25 of file SkMask.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
kCountMaskFormats

Definition at line 35 of file SkMask.h.

         {
        kCountMaskFormats = kSDF_Format + 1
    };

Format

enum SkMask::Format : uint8_t

Enumerator
kBW_Format	1bit per pixel mask (e.g. monochrome)
kA8_Format	8bits per pixel mask (e.g. antialiasing)
k3D_Format	3 8bit per pixl planes: alpha, mul, add
kARGB32_Format	SkPMColor.
kLCD16_Format	565 alpha for r/g/b
kSDF_Format	8bits representing signed distance field

Definition at line 26 of file SkMask.h.

                : uint8_t {
        kBW_Format, //!< 1bit per pixel mask (e.g. monochrome)
        kA8_Format, //!< 8bits per pixel mask (e.g. antialiasing)
        k3D_Format, //!< 3 8bit per pixl planes: alpha, mul, add
        kARGB32_Format,         //!< SkPMColor
        kLCD16_Format,          //!< 565 alpha for r/g/b
        kSDF_Format,            //!< 8bits representing signed distance field
    };

Constructor & Destructor Documentation

SkMask()

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

inline

Definition at line 39 of file SkMask.h.

        : fImage(img), fBounds(bounds), fRowBytes(rowBytes), fFormat(format) {}

Member Function Documentation

computeImageSize()

size_t SkMask::computeImageSize

(

)

const

Return the byte size of the mask, assuming only 1 plane. Does not account for k3D_Format. For that, use computeTotalImageSize(). If there is an overflow of 32bits, then returns 0.

Definition at line 30 of file SkMask.cpp.

                                      {
    return safeMul32(fBounds.height(), fRowBytes);
}

computeTotalImageSize()

size_t SkMask::computeTotalImageSize

(

)

const

Return the byte size of the mask, taking into account any extra planes (e.g. k3D_Format). If there is an overflow of 32bits, then returns 0.

Definition at line 34 of file SkMask.cpp.

                                           {
    size_t size = this->computeImageSize();
    if (fFormat == SkMask::k3D_Format) {
        size = safeMul32(SkToS32(size), 3);
    }
    return size;
}

getAddr()

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

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 112 of file SkMask.cpp.

                                              {
    SkASSERT(kBW_Format != fFormat);
    SkASSERT(fBounds.contains(x, y));
    SkASSERT(fImage);
 
    const char* addr = (const char*)fImage;
    addr += (y - fBounds.fTop) * fRowBytes;
    addr += (x - fBounds.fLeft) << maskFormatToShift(fFormat);
    return addr;
}

getAddr1()

const uint8_t * SkMask::getAddr1 ( int  x, int  y  ) const

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 68 of file SkMask.h.

                                                {
        SkASSERT(kBW_Format == fFormat);
        SkASSERT(fBounds.contains(x, y));
        SkASSERT(fImage != nullptr);
        return fImage + ((x - fBounds.fLeft) >> 3) + (y - fBounds.fTop) * fRowBytes;
    }

getAddr32()

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

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 104 of file SkMask.h.

                                                  {
        SkASSERT(kARGB32_Format == fFormat);
        SkASSERT(fBounds.contains(x, y));
        SkASSERT(fImage != nullptr);
        const uint32_t* row = (const uint32_t*)(fImage + (y - fBounds.fTop) * fRowBytes);
        return row + (x - fBounds.fLeft);
    }

getAddr8()

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

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 79 of file SkMask.h.

                                                {
        SkASSERT(kA8_Format == fFormat || kSDF_Format == fFormat);
        SkASSERT(fBounds.contains(x, y));
        SkASSERT(fImage != nullptr);
        return fImage + x - fBounds.fLeft + (y - fBounds.fTop) * fRowBytes;
    }

getAddrLCD16()

const uint16_t * SkMask::getAddrLCD16 ( int  x, int  y  ) const

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 91 of file SkMask.h.

                                                     {
        SkASSERT(kLCD16_Format == fFormat);
        SkASSERT(fBounds.contains(x, y));
        SkASSERT(fImage != nullptr);
        const uint16_t* row = (const uint16_t*)(fImage + (y - fBounds.fTop) * fRowBytes);
        return row + (x - fBounds.fLeft);
    }

isEmpty()

bool SkMask::isEmpty ( ) const

inline

Returns true if the mask is empty: i.e. it has an empty bounds.

Definition at line 50 of file SkMask.h.

{ return fBounds.isEmpty(); }

IsValidFormat()

static bool SkMask::IsValidFormat ( uint8_t  format )

inlinestatic

Definition at line 46 of file SkMask.h.

{ return format < kCountMaskFormats; }

Member Data Documentation

fBounds

const SkIRect SkMask::fBounds

Definition at line 42 of file SkMask.h.

fFormat

const Format SkMask::fFormat

Definition at line 44 of file SkMask.h.

fImage

uint8_t const* const SkMask::fImage

Definition at line 41 of file SkMask.h.

fRowBytes

const uint32_t SkMask::fRowBytes

Definition at line 43 of file SkMask.h.

---

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

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