/*
|
* Copyright 2006 The Android Open Source Project
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#ifndef SkMask_DEFINED
|
#define SkMask_DEFINED
|
|
#include "SkColorData.h"
|
#include "SkMacros.h"
|
#include "SkRect.h"
|
#include "SkTemplates.h"
|
|
#include <memory>
|
|
/** \class SkMask
|
SkMask is used to describe alpha bitmaps, either 1bit, 8bit, or
|
the 3-channel 3D format. These are passed to SkMaskFilter objects.
|
*/
|
struct SkMask {
|
SkMask() : fImage(nullptr) {}
|
|
enum Format {
|
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
|
};
|
|
enum {
|
kCountMaskFormats = kSDF_Format + 1
|
};
|
|
uint8_t* fImage;
|
SkIRect fBounds;
|
uint32_t fRowBytes;
|
Format fFormat;
|
|
/** Returns true if the mask is empty: i.e. it has an empty bounds.
|
*/
|
bool isEmpty() const { return fBounds.isEmpty(); }
|
|
/** 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.
|
*/
|
size_t computeImageSize() 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.
|
*/
|
size_t computeTotalImageSize() const;
|
|
/** 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.
|
*/
|
uint8_t* getAddr1(int x, int y) const {
|
SkASSERT(kBW_Format == fFormat);
|
SkASSERT(fBounds.contains(x, y));
|
SkASSERT(fImage != nullptr);
|
return fImage + ((x - fBounds.fLeft) >> 3) + (y - fBounds.fTop) * fRowBytes;
|
}
|
|
/** 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.
|
*/
|
uint8_t* getAddr8(int x, int y) const {
|
SkASSERT(kA8_Format == fFormat || kSDF_Format == fFormat);
|
SkASSERT(fBounds.contains(x, y));
|
SkASSERT(fImage != nullptr);
|
return fImage + x - fBounds.fLeft + (y - fBounds.fTop) * fRowBytes;
|
}
|
|
/**
|
* 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.
|
*/
|
uint16_t* getAddrLCD16(int x, int y) const {
|
SkASSERT(kLCD16_Format == fFormat);
|
SkASSERT(fBounds.contains(x, y));
|
SkASSERT(fImage != nullptr);
|
uint16_t* row = (uint16_t*)(fImage + (y - fBounds.fTop) * fRowBytes);
|
return row + (x - fBounds.fLeft);
|
}
|
|
/**
|
* 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.
|
*/
|
uint32_t* getAddr32(int x, int y) const {
|
SkASSERT(kARGB32_Format == fFormat);
|
SkASSERT(fBounds.contains(x, y));
|
SkASSERT(fImage != nullptr);
|
uint32_t* row = (uint32_t*)(fImage + (y - fBounds.fTop) * fRowBytes);
|
return row + (x - fBounds.fLeft);
|
}
|
|
/**
|
* 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).
|
*/
|
void* getAddr(int x, int y) const;
|
|
enum AllocType {
|
kUninit_Alloc,
|
kZeroInit_Alloc,
|
};
|
static uint8_t* AllocImage(size_t bytes, AllocType = kUninit_Alloc);
|
static void FreeImage(void* image);
|
|
enum CreateMode {
|
kJustComputeBounds_CreateMode, //!< compute bounds and return
|
kJustRenderImage_CreateMode, //!< render into preallocate mask
|
kComputeBoundsAndRenderImage_CreateMode //!< compute bounds, alloc image and render into it
|
};
|
|
/** Iterates over the coverage values along a scanline in a given SkMask::Format. Provides
|
* constructor, copy constructor for creating
|
* operator++, operator-- for iterating over the coverage values on a scanline
|
* operator>>= to add row bytes
|
* operator* to get the coverage value at the current location
|
* operator< to compare two iterators
|
*/
|
template <Format F> struct AlphaIter;
|
|
/**
|
* Returns initial destination mask data padded by radiusX and radiusY
|
*/
|
static SkMask PrepareDestination(int radiusX, int radiusY, const SkMask& src);
|
};
|
|
template <> struct SkMask::AlphaIter<SkMask::kBW_Format> {
|
AlphaIter(const uint8_t* ptr, int offset) : fPtr(ptr), fOffset(7 - offset) {}
|
AlphaIter(const AlphaIter& that) : fPtr(that.fPtr), fOffset(that.fOffset) {}
|
AlphaIter& operator++() {
|
if (0 < fOffset ) {
|
--fOffset;
|
} else {
|
++fPtr;
|
fOffset = 7;
|
}
|
return *this;
|
}
|
AlphaIter& operator--() {
|
if (fOffset < 7) {
|
++fOffset;
|
} else {
|
--fPtr;
|
fOffset = 0;
|
}
|
return *this;
|
}
|
AlphaIter& operator>>=(uint32_t rb) {
|
fPtr = SkTAddOffset<const uint8_t>(fPtr, rb);
|
return *this;
|
}
|
uint8_t operator*() const { return ((*fPtr) >> fOffset) & 1 ? 0xFF : 0; }
|
bool operator<(const AlphaIter& that) const {
|
return fPtr < that.fPtr || (fPtr == that.fPtr && fOffset > that.fOffset);
|
}
|
const uint8_t* fPtr;
|
int fOffset;
|
};
|
|
template <> struct SkMask::AlphaIter<SkMask::kA8_Format> {
|
AlphaIter(const uint8_t* ptr) : fPtr(ptr) {}
|
AlphaIter(const AlphaIter& that) : fPtr(that.fPtr) {}
|
AlphaIter& operator++() { ++fPtr; return *this; }
|
AlphaIter& operator--() { --fPtr; return *this; }
|
AlphaIter& operator>>=(uint32_t rb) {
|
fPtr = SkTAddOffset<const uint8_t>(fPtr, rb);
|
return *this;
|
}
|
uint8_t operator*() const { return *fPtr; }
|
bool operator<(const AlphaIter& that) const { return fPtr < that.fPtr; }
|
const uint8_t* fPtr;
|
};
|
|
template <> struct SkMask::AlphaIter<SkMask::kARGB32_Format> {
|
AlphaIter(const uint32_t* ptr) : fPtr(ptr) {}
|
AlphaIter(const AlphaIter& that) : fPtr(that.fPtr) {}
|
AlphaIter& operator++() { ++fPtr; return *this; }
|
AlphaIter& operator--() { --fPtr; return *this; }
|
AlphaIter& operator>>=(uint32_t rb) {
|
fPtr = SkTAddOffset<const uint32_t>(fPtr, rb);
|
return *this;
|
}
|
uint8_t operator*() const { return SkGetPackedA32(*fPtr); }
|
bool operator<(const AlphaIter& that) const { return fPtr < that.fPtr; }
|
const uint32_t* fPtr;
|
};
|
|
template <> struct SkMask::AlphaIter<SkMask::kLCD16_Format> {
|
AlphaIter(const uint16_t* ptr) : fPtr(ptr) {}
|
AlphaIter(const AlphaIter& that) : fPtr(that.fPtr) {}
|
AlphaIter& operator++() { ++fPtr; return *this; }
|
AlphaIter& operator--() { --fPtr; return *this; }
|
AlphaIter& operator>>=(uint32_t rb) {
|
fPtr = SkTAddOffset<const uint16_t>(fPtr, rb);
|
return *this;
|
}
|
uint8_t operator*() const {
|
unsigned packed = *fPtr;
|
unsigned r = SkPacked16ToR32(packed);
|
unsigned g = SkPacked16ToG32(packed);
|
unsigned b = SkPacked16ToB32(packed);
|
return (r + g + b) / 3;
|
}
|
bool operator<(const AlphaIter& that) const { return fPtr < that.fPtr; }
|
const uint16_t* fPtr;
|
};
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
/**
|
* \using SkAutoMaskImage
|
*
|
* Stack class used to manage the fImage buffer in a SkMask.
|
* When this object loses scope, the buffer is freed with SkMask::FreeImage().
|
*/
|
using SkAutoMaskFreeImage = std::unique_ptr<uint8_t,SkFunctionWrapper<void,void,SkMask::FreeImage>>;
|
#define SkAutoMaskFreeImage(...) SK_REQUIRE_LOCAL_VAR(SkAutoMaskFreeImage)
|
|
#endif
|
