blob: 0c259d692aa974831cb5118d8e15ba35d34d4709 [file] [log] [blame]
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkTextureCompressor_Blitter_DEFINED
#define SkTextureCompressor_Blitter_DEFINED
#include "SkTypes.h"
#include "SkBlitter.h"
namespace SkTextureCompressor {
// Ostensibly, SkBlitter::BlitRect is supposed to set a rect of pixels to full
// alpha. This becomes problematic when using compressed texture blitters, since
// the rect rarely falls along block boundaries. The proper way to handle this is
// to update the compressed encoding of a block by resetting the proper parameters
// (and even recompressing the block) where a rect falls inbetween block boundaries.
// PEDANTIC_BLIT_RECT attempts to do this by requiring the struct passed to
// SkTCompressedAlphaBlitter to implement an UpdateBlock function call.
//
// However, the way that BlitRect gets used almost exclusively is to bracket inverse
// fills for paths. In other words, the top few rows and bottom few rows of a path
// that's getting inverse filled are called using blitRect. The rest are called using
// the standard blitAntiH. As a result, we can just call blitAntiH with a faux RLE
// of full alpha values, and then check in our flush() call that we don't run off the
// edge of the buffer. This is why we do not need this flag to be turned on.
//
// NOTE: This code is unfinished, but is inteded as a starting point if an when
// bugs are introduced from the existing code.
#define PEDANTIC_BLIT_RECT 0
// This class implements a blitter that blits directly into a buffer that will
// be used as an compressed alpha texture. We compute this buffer by
// buffering scan lines and then outputting them all at once. The number of
// scan lines buffered is controlled by kBlockSize
//
// The CompressorType is a struct with a bunch of static methods that provides
// the specialized compression functionality of the blitter. A complete CompressorType
// will implement the following static functions;
//
// struct CompressorType {
// // The function used to compress an A8 block. The layout of the
// // block is also expected to be in column-major order.
// static void CompressA8Vertical(uint8_t* dst, const uint8_t block[]);
//
// // The function used to compress an A8 block. The layout of the
// // block is also expected to be in row-major order.
// static void CompressA8Horizontal(uint8_t* dst, const uint8_t* src, int srcRowBytes);
//
#if PEDANTIC_BLIT_RECT
// // The function used to update an already compressed block. This will
// // most likely be implementation dependent. The mask variable will have
// // 0xFF in positions where the block should be updated and 0 in positions
// // where it shouldn't. src contains an uncompressed buffer of pixels.
// static void UpdateBlock(uint8_t* dst, const uint8_t* src, int srcRowBytes,
// const uint8_t* mask);
#endif
// };
template<int BlockDim, int EncodedBlockSize, typename CompressorType>
class SkTCompressedAlphaBlitter : public SkBlitter {
public:
SkTCompressedAlphaBlitter(int width, int height, void *compressedBuffer)
// 0x7FFE is one minus the largest positive 16-bit int. We use it for
// debugging to make sure that we're properly setting the nextX distance
// in flushRuns().
#ifdef SK_DEBUG
: fCalledOnceWithNonzeroY(false)
, fBlitMaskCalled(false),
#else
:
#endif
kLongestRun(0x7FFE), kZeroAlpha(0)
, fNextRun(0)
, fWidth(width)
, fHeight(height)
, fBuffer(compressedBuffer)
{
SkASSERT((width % BlockDim) == 0);
SkASSERT((height % BlockDim) == 0);
}
virtual ~SkTCompressedAlphaBlitter() { this->flushRuns(); }
// Blit a horizontal run of one or more pixels.
void blitH(int x, int y, int width) override {
// This function is intended to be called from any standard RGB
// buffer, so we should never encounter it. However, if some code
// path does end up here, then this needs to be investigated.
SkFAIL("Not implemented!");
}
// Blit a horizontal run of antialiased pixels; runs[] is a *sparse*
// zero-terminated run-length encoding of spans of constant alpha values.
void blitAntiH(int x, int y,
const SkAlpha antialias[],
const int16_t runs[]) override {
SkASSERT(0 == x);
// Make sure that the new row to blit is either the first
// row that we're blitting, or it's exactly the next scan row
// since the last row that we blit. This is to ensure that when
// we go to flush the runs, that they are all the same four
// runs.
if (fNextRun > 0 &&
((x != fBufferedRuns[fNextRun-1].fX) ||
(y-1 != fBufferedRuns[fNextRun-1].fY))) {
this->flushRuns();
}
// Align the rows to a block boundary. If we receive rows that
// are not on a block boundary, then fill in the preceding runs
// with zeros. We do this by producing a single RLE that says
// that we have 0x7FFE pixels of zero (0x7FFE = 32766).
const int row = BlockDim * (y / BlockDim);
while ((row + fNextRun) < y) {
fBufferedRuns[fNextRun].fAlphas = &kZeroAlpha;
fBufferedRuns[fNextRun].fRuns = &kLongestRun;
fBufferedRuns[fNextRun].fX = 0;
fBufferedRuns[fNextRun].fY = row + fNextRun;
++fNextRun;
}
// Make sure that our assumptions aren't violated...
SkASSERT(fNextRun == (y % BlockDim));
SkASSERT(fNextRun == 0 || fBufferedRuns[fNextRun - 1].fY < y);
// Set the values of the next run
fBufferedRuns[fNextRun].fAlphas = antialias;
fBufferedRuns[fNextRun].fRuns = runs;
fBufferedRuns[fNextRun].fX = x;
fBufferedRuns[fNextRun].fY = y;
// If we've output a block of scanlines in a row that don't violate our
// assumptions, then it's time to flush them...
if (BlockDim == ++fNextRun) {
this->flushRuns();
}
}
// Blit a vertical run of pixels with a constant alpha value.
void blitV(int x, int y, int height, SkAlpha alpha) override {
// This function is currently not implemented. It is not explicitly
// required by the contract, but if at some time a code path runs into
// this function (which is entirely possible), it needs to be implemented.
//
// TODO (krajcevski):
// This function will be most easily implemented in one of two ways:
// 1. Buffer each vertical column value and then construct a list
// of alpha values and output all of the blocks at once. This only
// requires a write to the compressed buffer
// 2. Replace the indices of each block with the proper indices based
// on the alpha value. This requires a read and write of the compressed
// buffer, but much less overhead.
SkFAIL("Not implemented!");
}
// Blit a solid rectangle one or more pixels wide. It's assumed that blitRect
// is called as a way to bracket blitAntiH where above and below the path the
// called path just needs a solid rectangle to fill in the mask.
#ifdef SK_DEBUG
bool fCalledOnceWithNonzeroY;
#endif
void blitRect(int x, int y, int width, int height) override {
// Assumptions:
SkASSERT(0 == x);
SkASSERT(width <= fWidth);
// Make sure that we're only ever bracketing calls to blitAntiH.
SkASSERT((0 == y) || (!fCalledOnceWithNonzeroY && (fCalledOnceWithNonzeroY = true)));
#if !(PEDANTIC_BLIT_RECT)
for (int i = 0; i < height; ++i) {
const SkAlpha kFullAlpha = 0xFF;
this->blitAntiH(x, y+i, &kFullAlpha, &kLongestRun);
}
#else
const int startBlockX = (x / BlockDim) * BlockDim;
const int startBlockY = (y / BlockDim) * BlockDim;
const int endBlockX = ((x + width) / BlockDim) * BlockDim;
const int endBlockY = ((y + height) / BlockDim) * BlockDim;
// If start and end are the same, then we only need to update a single block...
if (startBlockY == endBlockY && startBlockX == endBlockX) {
uint8_t mask[BlockDim*BlockDim];
memset(mask, 0, sizeof(mask));
const int xoff = x - startBlockX;
SkASSERT((xoff + width) <= BlockDim);
const int yoff = y - startBlockY;
SkASSERT((yoff + height) <= BlockDim);
for (int j = 0; j < height; ++j) {
memset(mask + (j + yoff)*BlockDim + xoff, 0xFF, width);
}
uint8_t* dst = this->getBlock(startBlockX, startBlockY);
CompressorType::UpdateBlock(dst, mask, BlockDim, mask);
// If start and end are the same in the y dimension, then we can freely update an
// entire row of blocks...
} else if (startBlockY == endBlockY) {
this->updateBlockRow(x, y, width, height, startBlockY, startBlockX, endBlockX);
// Similarly, if the start and end are in the same column, then we can just update
// an entire column of blocks...
} else if (startBlockX == endBlockX) {
this->updateBlockCol(x, y, width, height, startBlockX, startBlockY, endBlockY);
// Otherwise, the rect spans a non-trivial region of blocks, and we have to construct
// a kind of 9-patch to update each of the pieces of the rect. The top and bottom
// rows are updated using updateBlockRow, and the left and right columns are updated
// using updateBlockColumn. Anything in the middle is simply memset to an opaque block
// encoding.
} else {
const int innerStartBlockX = startBlockX + BlockDim;
const int innerStartBlockY = startBlockY + BlockDim;
// Blit top row
const int topRowHeight = innerStartBlockY - y;
this->updateBlockRow(x, y, width, topRowHeight, startBlockY,
startBlockX, endBlockX);
// Advance y
y += topRowHeight;
height -= topRowHeight;
// Blit middle
if (endBlockY > innerStartBlockY) {
// Update left row
this->updateBlockCol(x, y, innerStartBlockX - x, endBlockY, startBlockY,
startBlockX, innerStartBlockX);
// Update the middle with an opaque encoding...
uint8_t mask[BlockDim*BlockDim];
memset(mask, 0xFF, sizeof(mask));
uint8_t opaqueEncoding[EncodedBlockSize];
CompressorType::CompressA8Horizontal(opaqueEncoding, mask, BlockDim);
for (int j = innerStartBlockY; j < endBlockY; j += BlockDim) {
uint8_t* opaqueDst = this->getBlock(innerStartBlockX, j);
for (int i = innerStartBlockX; i < endBlockX; i += BlockDim) {
memcpy(opaqueDst, opaqueEncoding, EncodedBlockSize);
opaqueDst += EncodedBlockSize;
}
}
// If we need to update the right column, do that too
if (x + width > endBlockX) {
this->updateBlockCol(endBlockX, y, x + width - endBlockX, endBlockY,
endBlockX, innerStartBlockY, endBlockY);
}
// Advance y
height = y + height - endBlockY;
y = endBlockY;
}
// If we need to update the last row, then do that, too.
if (height > 0) {
this->updateBlockRow(x, y, width, height, endBlockY,
startBlockX, endBlockX);
}
}
#endif
}
// Blit a rectangle with one alpha-blended column on the left,
// width (zero or more) opaque pixels, and one alpha-blended column
// on the right. The result will always be at least two pixels wide.
void blitAntiRect(int x, int y, int width, int height,
SkAlpha leftAlpha, SkAlpha rightAlpha) override {
// This function is currently not implemented. It is not explicitly
// required by the contract, but if at some time a code path runs into
// this function (which is entirely possible), it needs to be implemented.
//
// TODO (krajcevski):
// This function will be most easily implemented as follows:
// 1. If width/height are smaller than a block, then update the
// indices of the affected blocks.
// 2. If width/height are larger than a block, then construct a 9-patch
// of block encodings that represent the rectangle, and write them
// to the compressed buffer as necessary. Whether or not the blocks
// are overwritten by zeros or just their indices are updated is up
// to debate.
SkFAIL("Not implemented!");
}
// Blit a pattern of pixels defined by a rectangle-clipped mask; We make an
// assumption here that if this function gets called, then it will replace all
// of the compressed texture blocks that it touches. Hence, two separate calls
// to blitMask that have clips next to one another will cause artifacts. Most
// of the time, however, this function gets called because constructing the mask
// was faster than constructing the RLE for blitAntiH, and this function will
// only be called once.
#ifdef SK_DEBUG
bool fBlitMaskCalled;
#endif
void blitMask(const SkMask& mask, const SkIRect& clip) override {
// Assumptions:
SkASSERT(!fBlitMaskCalled);
SkDEBUGCODE(fBlitMaskCalled = true);
SkASSERT(SkMask::kA8_Format == mask.fFormat);
SkASSERT(mask.fBounds.contains(clip));
// Start from largest block boundary less than the clip boundaries.
const int startI = BlockDim * (clip.left() / BlockDim);
const int startJ = BlockDim * (clip.top() / BlockDim);
for (int j = startJ; j < clip.bottom(); j += BlockDim) {
// Get the destination for this block row
uint8_t* dst = this->getBlock(startI, j);
for (int i = startI; i < clip.right(); i += BlockDim) {
// At this point, the block should intersect the clip.
SkASSERT(SkIRect::IntersectsNoEmptyCheck(
SkIRect::MakeXYWH(i, j, BlockDim, BlockDim), clip));
// Do we need to pad it?
if (i < clip.left() || j < clip.top() ||
i + BlockDim > clip.right() || j + BlockDim > clip.bottom()) {
uint8_t block[BlockDim*BlockDim];
memset(block, 0, sizeof(block));
const int startX = SkMax32(i, clip.left());
const int startY = SkMax32(j, clip.top());
const int endX = SkMin32(i + BlockDim, clip.right());
const int endY = SkMin32(j + BlockDim, clip.bottom());
for (int y = startY; y < endY; ++y) {
const int col = startX - i;
const int row = y - j;
const int valsWide = endX - startX;
SkASSERT(valsWide <= BlockDim);
SkASSERT(0 <= col && col < BlockDim);
SkASSERT(0 <= row && row < BlockDim);
memcpy(block + row*BlockDim + col,
mask.getAddr8(startX, j + row), valsWide);
}
CompressorType::CompressA8Horizontal(dst, block, BlockDim);
} else {
// Otherwise, just compress it.
uint8_t*const src = mask.getAddr8(i, j);
const uint32_t rb = mask.fRowBytes;
CompressorType::CompressA8Horizontal(dst, src, rb);
}
dst += EncodedBlockSize;
}
}
}
// If the blitter just sets a single value for each pixel, return the
// bitmap it draws into, and assign value. If not, return nullptr and ignore
// the value parameter.
const SkPixmap* justAnOpaqueColor(uint32_t* value) override {
return nullptr;
}
/**
* Compressed texture blitters only really work correctly if they get
* BlockDim rows at a time. That being said, this blitter tries it's best
* to preserve semantics if blitAntiH doesn't get called in too many
* weird ways...
*/
int requestRowsPreserved() const override { return BlockDim; }
private:
static const int kPixelsPerBlock = BlockDim * BlockDim;
// The longest possible run of pixels that this blitter will receive.
// This is initialized in the constructor to 0x7FFE, which is one less
// than the largest positive 16-bit integer. We make sure that it's one
// less for debugging purposes. We also don't make this variable static
// in order to make sure that we can construct a valid pointer to it.
const int16_t kLongestRun;
// Usually used in conjunction with kLongestRun. This is initialized to
// zero.
const SkAlpha kZeroAlpha;
// This is the information that we buffer whenever we're asked to blit
// a row with this blitter.
struct BufferedRun {
const SkAlpha* fAlphas;
const int16_t* fRuns;
int fX, fY;
} fBufferedRuns[BlockDim];
// The next row [0, BlockDim) that we need to blit.
int fNextRun;
// The width and height of the image that we're blitting
const int fWidth;
const int fHeight;
// The compressed buffer that we're blitting into. It is assumed that the buffer
// is large enough to store a compressed image of size fWidth*fHeight.
void* const fBuffer;
// Various utility functions
int blocksWide() const { return fWidth / BlockDim; }
int blocksTall() const { return fHeight / BlockDim; }
int totalBlocks() const { return (fWidth * fHeight) / kPixelsPerBlock; }
// Returns the block index for the block containing pixel (x, y). Block
// indices start at zero and proceed in raster order.
int getBlockOffset(int x, int y) const {
SkASSERT(x < fWidth);
SkASSERT(y < fHeight);
const int blockCol = x / BlockDim;
const int blockRow = y / BlockDim;
return blockRow * this->blocksWide() + blockCol;
}
// Returns a pointer to the block containing pixel (x, y)
uint8_t *getBlock(int x, int y) const {
uint8_t* ptr = reinterpret_cast<uint8_t*>(fBuffer);
return ptr + EncodedBlockSize*this->getBlockOffset(x, y);
}
// Updates the block whose columns are stored in block. curAlphai is expected
// to store the alpha values that will be placed within each of the columns in
// the range [col, col+colsLeft).
typedef uint32_t Column[BlockDim/4];
typedef uint32_t Block[BlockDim][BlockDim/4];
inline void updateBlockColumns(Block block, const int col,
const int colsLeft, const Column curAlphai) {
SkASSERT(block);
SkASSERT(col + colsLeft <= BlockDim);
for (int i = col; i < (col + colsLeft); ++i) {
memcpy(block[i], curAlphai, sizeof(Column));
}
}
// The following function writes the buffered runs to compressed blocks.
// If fNextRun < BlockDim, then we fill the runs that we haven't buffered with
// the constant zero buffer.
void flushRuns() {
// If we don't have any runs, then just return.
if (0 == fNextRun) {
return;
}
#ifndef NDEBUG
// Make sure that if we have any runs, they all match
for (int i = 1; i < fNextRun; ++i) {
SkASSERT(fBufferedRuns[i].fY == fBufferedRuns[i-1].fY + 1);
SkASSERT(fBufferedRuns[i].fX == fBufferedRuns[i-1].fX);
}
#endif
// If we don't have as many runs as we have rows, fill in the remaining
// runs with constant zeros.
for (int i = fNextRun; i < BlockDim; ++i) {
fBufferedRuns[i].fY = fBufferedRuns[0].fY + i;
fBufferedRuns[i].fX = fBufferedRuns[0].fX;
fBufferedRuns[i].fAlphas = &kZeroAlpha;
fBufferedRuns[i].fRuns = &kLongestRun;
}
// Make sure that our assumptions aren't violated.
SkASSERT(fNextRun > 0 && fNextRun <= BlockDim);
SkASSERT((fBufferedRuns[0].fY % BlockDim) == 0);
// The following logic walks BlockDim rows at a time and outputs compressed
// blocks to the buffer passed into the constructor.
// We do the following:
//
// c1 c2 c3 c4
// -----------------------------------------------------------------------
// ... | | | | | ----> fBufferedRuns[0]
// -----------------------------------------------------------------------
// ... | | | | | ----> fBufferedRuns[1]
// -----------------------------------------------------------------------
// ... | | | | | ----> fBufferedRuns[2]
// -----------------------------------------------------------------------
// ... | | | | | ----> fBufferedRuns[3]
// -----------------------------------------------------------------------
//
// curX -- the macro X value that we've gotten to.
// c[BlockDim] -- the buffers that represent the columns of the current block
// that we're operating on
// curAlphaColumn -- buffer containing the column of alpha values from fBufferedRuns.
// nextX -- for each run, the next point at which we need to update curAlphaColumn
// after the value of curX.
// finalX -- the minimum of all the nextX values.
//
// curX advances to finalX outputting any blocks that it passes along
// the way. Since finalX will not change when we reach the end of a
// run, the termination criteria will be whenever curX == finalX at the
// end of a loop.
// Setup:
Block block;
sk_bzero(block, sizeof(block));
Column curAlphaColumn;
sk_bzero(curAlphaColumn, sizeof(curAlphaColumn));
SkAlpha *curAlpha = reinterpret_cast<SkAlpha*>(&curAlphaColumn);
int nextX[BlockDim];
for (int i = 0; i < BlockDim; ++i) {
nextX[i] = 0x7FFFFF;
}
uint8_t* outPtr = this->getBlock(fBufferedRuns[0].fX, fBufferedRuns[0].fY);
// Populate the first set of runs and figure out how far we need to
// advance on the first step
int curX = 0;
int finalX = 0xFFFFF;
for (int i = 0; i < BlockDim; ++i) {
nextX[i] = *(fBufferedRuns[i].fRuns);
curAlpha[i] = *(fBufferedRuns[i].fAlphas);
finalX = SkMin32(nextX[i], finalX);
}
// Make sure that we have a valid right-bound X value
SkASSERT(finalX < 0xFFFFF);
// If the finalX is the longest run, then just blit until we have
// width...
if (kLongestRun == finalX) {
finalX = fWidth;
}
// Run the blitter...
while (curX != finalX) {
SkASSERT(finalX >= curX);
// Do we need to populate the rest of the block?
if ((finalX - (BlockDim*(curX / BlockDim))) >= BlockDim) {
const int col = curX % BlockDim;
const int colsLeft = BlockDim - col;
SkASSERT(curX + colsLeft <= finalX);
this->updateBlockColumns(block, col, colsLeft, curAlphaColumn);
// Write this block
CompressorType::CompressA8Vertical(outPtr, reinterpret_cast<uint8_t*>(block));
outPtr += EncodedBlockSize;
curX += colsLeft;
}
// If we can advance even further, then just keep memsetting the block
if ((finalX - curX) >= BlockDim) {
SkASSERT((curX % BlockDim) == 0);
const int col = 0;
const int colsLeft = BlockDim;
this->updateBlockColumns(block, col, colsLeft, curAlphaColumn);
// While we can keep advancing, just keep writing the block.
uint8_t lastBlock[EncodedBlockSize];
CompressorType::CompressA8Vertical(lastBlock, reinterpret_cast<uint8_t*>(block));
while((finalX - curX) >= BlockDim) {
memcpy(outPtr, lastBlock, EncodedBlockSize);
outPtr += EncodedBlockSize;
curX += BlockDim;
}
}
// If we haven't advanced within the block then do so.
if (curX < finalX) {
const int col = curX % BlockDim;
const int colsLeft = finalX - curX;
this->updateBlockColumns(block, col, colsLeft, curAlphaColumn);
curX += colsLeft;
}
SkASSERT(curX == finalX);
// Figure out what the next advancement is...
if (finalX < fWidth) {
for (int i = 0; i < BlockDim; ++i) {
if (nextX[i] == finalX) {
const int16_t run = *(fBufferedRuns[i].fRuns);
fBufferedRuns[i].fRuns += run;
fBufferedRuns[i].fAlphas += run;
curAlpha[i] = *(fBufferedRuns[i].fAlphas);
nextX[i] += *(fBufferedRuns[i].fRuns);
}
}
finalX = 0xFFFFF;
for (int i = 0; i < BlockDim; ++i) {
finalX = SkMin32(nextX[i], finalX);
}
} else {
curX = finalX;
}
}
// If we didn't land on a block boundary, output the block...
if ((curX % BlockDim) > 0) {
#ifdef SK_DEBUG
for (int i = 0; i < BlockDim; ++i) {
SkASSERT(nextX[i] == kLongestRun || nextX[i] == curX);
}
#endif
const int col = curX % BlockDim;
const int colsLeft = BlockDim - col;
memset(curAlphaColumn, 0, sizeof(curAlphaColumn));
this->updateBlockColumns(block, col, colsLeft, curAlphaColumn);
CompressorType::CompressA8Vertical(outPtr, reinterpret_cast<uint8_t*>(block));
}
fNextRun = 0;
}
#if PEDANTIC_BLIT_RECT
void updateBlockRow(int x, int y, int width, int height,
int blockRow, int startBlockX, int endBlockX) {
if (0 == width || 0 == height || startBlockX == endBlockX) {
return;
}
uint8_t* dst = this->getBlock(startBlockX, BlockDim * (y / BlockDim));
// One horizontal strip to update
uint8_t mask[BlockDim*BlockDim];
memset(mask, 0, sizeof(mask));
// Update the left cap
int blockX = startBlockX;
const int yoff = y - blockRow;
for (int j = 0; j < height; ++j) {
const int xoff = x - blockX;
memset(mask + (j + yoff)*BlockDim + xoff, 0xFF, BlockDim - xoff);
}
CompressorType::UpdateBlock(dst, mask, BlockDim, mask);
dst += EncodedBlockSize;
blockX += BlockDim;
// Update the middle
if (blockX < endBlockX) {
for (int j = 0; j < height; ++j) {
memset(mask + (j + yoff)*BlockDim, 0xFF, BlockDim);
}
while (blockX < endBlockX) {
CompressorType::UpdateBlock(dst, mask, BlockDim, mask);
dst += EncodedBlockSize;
blockX += BlockDim;
}
}
SkASSERT(endBlockX == blockX);
// Update the right cap (if we need to)
if (x + width > endBlockX) {
memset(mask, 0, sizeof(mask));
for (int j = 0; j < height; ++j) {
const int xoff = (x+width-blockX);
memset(mask + (j+yoff)*BlockDim, 0xFF, xoff);
}
CompressorType::UpdateBlock(dst, mask, BlockDim, mask);
}
}
void updateBlockCol(int x, int y, int width, int height,
int blockCol, int startBlockY, int endBlockY) {
if (0 == width || 0 == height || startBlockY == endBlockY) {
return;
}
// One vertical strip to update
uint8_t mask[BlockDim*BlockDim];
memset(mask, 0, sizeof(mask));
const int maskX0 = x - blockCol;
const int maskWidth = maskX0 + width;
SkASSERT(maskWidth <= BlockDim);
// Update the top cap
int blockY = startBlockY;
for (int j = (y - blockY); j < BlockDim; ++j) {
memset(mask + maskX0 + j*BlockDim, 0xFF, maskWidth);
}
CompressorType::UpdateBlock(this->getBlock(blockCol, blockY), mask, BlockDim, mask);
blockY += BlockDim;
// Update middle
if (blockY < endBlockY) {
for (int j = 0; j < BlockDim; ++j) {
memset(mask + maskX0 + j*BlockDim, 0xFF, maskWidth);
}
while (blockY < endBlockY) {
CompressorType::UpdateBlock(this->getBlock(blockCol, blockY),
mask, BlockDim, mask);
blockY += BlockDim;
}
}
SkASSERT(endBlockY == blockY);
// Update bottom
if (y + height > endBlockY) {
for (int j = y+height; j < endBlockY + BlockDim; ++j) {
memset(mask + (j-endBlockY)*BlockDim, 0, BlockDim);
}
CompressorType::UpdateBlock(this->getBlock(blockCol, blockY),
mask, BlockDim, mask);
}
}
#endif // PEDANTIC_BLIT_RECT
};
} // namespace SkTextureCompressor
#endif // SkTextureCompressor_Blitter_DEFINED