SkARGB32_Blitter Class Reference

#include <SkCoreBlitters.h>

Inheritance diagram for SkARGB32_Blitter:

Public Member Functions
	SkARGB32_Blitter (const SkPixmap &device, const SkPaint &paint)
void	blitH (int x, int y, int width) override
	Blit a horizontal run of one or more pixels.
void	blitAntiH (int x, int y, const SkAlpha antialias[], const int16_t runs[]) override
void	blitV (int x, int y, int height, SkAlpha alpha) override
	Blit a vertical run of pixels with a constant alpha value.
void	blitRect (int x, int y, int width, int height) override
	Blit a solid rectangle one or more pixels wide.
void	blitMask (const SkMask &, const SkIRect &) override
void	blitAntiH2 (int x, int y, U8CPU a0, U8CPU a1) override
void	blitAntiV2 (int x, int y, U8CPU a0, U8CPU a1) override
Public Member Functions inherited from SkRasterBlitter
	SkRasterBlitter (const SkPixmap &device)
Public Member Functions inherited from SkBlitter
virtual	~SkBlitter ()
virtual void	blitAntiRect (int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha)
void	blitFatAntiRect (const SkRect &rect)
virtual bool	isNullBlitter () const
virtual int	requestRowsPreserved () const
virtual void *	allocBlitMemory (size_t sz)
void	blitRectRegion (const SkIRect &rect, const SkRegion &clip)
void	blitRegion (const SkRegion &clip)

Protected Attributes
SkColor	fColor
SkPMColor	fPMColor
Protected Attributes inherited from SkRasterBlitter
const SkPixmap	fDevice
Protected Attributes inherited from SkBlitter
SkAutoMalloc	fBlitMemory

Additional Inherited Members
Static Public Member Functions inherited from SkBlitter
static bool	UseLegacyBlitter (const SkPixmap &, const SkPaint &, const SkMatrix &)
static SkBlitter *	Choose (const SkPixmap &dst, const SkMatrix &ctm, const SkPaint &paint, SkArenaAlloc *, bool drawCoverage, sk_sp< SkShader > clipShader, const SkSurfaceProps &props)
static SkBlitter *	ChooseSprite (const SkPixmap &dst, const SkPaint &, const SkPixmap &src, int left, int top, SkArenaAlloc *, sk_sp< SkShader > clipShader)

Detailed Description

Definition at line 66 of file SkCoreBlitters.h.

Constructor & Destructor Documentation

SkARGB32_Blitter()

SkARGB32_Blitter::SkARGB32_Blitter	(	const SkPixmap &	device,
		const SkPaint &	paint
	)

Definition at line 1445 of file SkBlitter_ARGB32.cpp.

        : INHERITED(device) {
    SkColor color = paint.getColor();
    fColor = color;
 
    fSrcA = SkColorGetA(color);
    unsigned scale = SkAlpha255To256(fSrcA);
    fSrcR = SkAlphaMul(SkColorGetR(color), scale);
    fSrcG = SkAlphaMul(SkColorGetG(color), scale);
    fSrcB = SkAlphaMul(SkColorGetB(color), scale);
 
    fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
}

Member Function Documentation

blitAntiH()

void SkARGB32_Blitter::blitAntiH ( int  x, int  y, const SkAlpha  antialias[], const int16_t  runs[]  )

overridevirtual

Blit a horizontal run of antialiased pixels; runs[] is a sparse zero-terminated run-length encoding of spans of constant alpha values. The runs[] and antialias[] work together to represent long runs of pixels with the same alphas. The runs[] contains the number of pixels with the same alpha, and antialias[] contain the coverage value for that number of pixels. The runs[] (and antialias[]) are encoded in a clever way. The runs array is zero terminated, and has enough entries for each pixel plus one, in most cases some of the entries will not contain valid data. An entry in the runs array contains the number of pixels (np) that have the same alpha value. The next np value is found np entries away. For example, if runs[0] = 7, then the next valid entry will by at runs[7]. The runs array and antialias[] are coupled by index. So, if the np entry is at runs[45] = 12 then the alpha value can be found at antialias[45] = 0x88. This would mean to use an alpha value of 0x88 for the next 12 pixels starting at pixel 45.

Implements SkBlitter.

Definition at line 1471 of file SkBlitter_ARGB32.cpp.

                                                       {
    if (fSrcA == 0) {
        return;
    }
 
    uint32_t    color = fPMColor;
    uint32_t*   device = fDevice.writable_addr32(x, y);
    unsigned    opaqueMask = fSrcA; // if fSrcA is 0xFF, then we will catch the fast opaque case
 
    for (;;) {
        int count = runs[0];
        SkASSERT(count >= 0);
        if (count <= 0) {
            return;
        }
        unsigned aa = antialias[0];
        if (aa) {
            if ((opaqueMask & aa) == 255) {
                SkOpts::memset32(device, color, count);
            } else {
                uint32_t sc = SkAlphaMulQ(color, SkAlpha255To256(aa));
                SkBlitRow::Color32(device, count, sc);
            }
        }
        runs += count;
        antialias += count;
        device += count;
    }
}

blitAntiH2()

void SkARGB32_Blitter::blitAntiH2 ( int  x, int  y, U8CPU  a0, U8CPU  a1  )

overridevirtual

Reimplemented from SkBlitter.

Reimplemented in SkARGB32_Opaque_Blitter.

Definition at line 1502 of file SkBlitter_ARGB32.cpp.

                                                                  {
    uint32_t* device = fDevice.writable_addr32(x, y);
    SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);)
 
    device[0] = SkBlendARGB32(fPMColor, device[0], a0);
    device[1] = SkBlendARGB32(fPMColor, device[1], a1);
}

blitAntiV2()

void SkARGB32_Blitter::blitAntiV2 ( int  x, int  y, U8CPU  a0, U8CPU  a1  )

overridevirtual

Reimplemented from SkBlitter.

Reimplemented in SkARGB32_Opaque_Blitter.

Definition at line 1510 of file SkBlitter_ARGB32.cpp.

                                                                  {
    uint32_t* device = fDevice.writable_addr32(x, y);
    SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);)
 
    device[0] = SkBlendARGB32(fPMColor, device[0], a0);
    device = (uint32_t*)((char*)device + fDevice.rowBytes());
    device[0] = SkBlendARGB32(fPMColor, device[0], a1);
}

blitH()

void SkARGB32_Blitter::blitH ( int  x, int  y, int  width  )

overridevirtual

Blit a horizontal run of one or more pixels.

Implements SkBlitter.

Definition at line 1464 of file SkBlitter_ARGB32.cpp.

                                                    {
    SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
 
    uint32_t* device = fDevice.writable_addr32(x, y);
    SkBlitRow::Color32(device, width, fPMColor);
}

blitMask()

void SkARGB32_Blitter::blitMask ( const SkMask &  mask, const SkIRect &  clip  )

overridevirtual

Blit a pattern of pixels defined by a rectangle-clipped mask; typically used for text.

Reimplemented from SkBlitter.

Reimplemented in SkARGB32_Opaque_Blitter.

Definition at line 1559 of file SkBlitter_ARGB32.cpp.

                                                                       {
    SkASSERT(mask.fBounds.contains(clip));
    SkASSERT(fSrcA != 0xFF);
 
    if (fSrcA == 0) {
        return;
    }
 
    if (blit_color(fDevice, mask, clip, fColor)) {
        return;
    }
 
    switch (mask.fFormat) {
        case SkMask::kBW_Format:
            SkARGB32_BlendBW(fDevice, mask, clip, fPMColor, SkAlpha255To256(255 - fSrcA));
            break;
        case SkMask::kARGB32_Format:
            SkARGB32_Blit32(fDevice, mask, clip, fPMColor);
            break;
        default:
            SK_ABORT("Mask format not handled.");
    }
}

blitRect()

void SkARGB32_Blitter::blitRect ( int  x, int  y, int  width, int  height  )

overridevirtual

Blit a solid rectangle one or more pixels wide.

Reimplemented from SkBlitter.

Definition at line 1642 of file SkBlitter_ARGB32.cpp.

                                                                   {
    SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width() && y + height <= fDevice.height());
 
    if (fSrcA == 0) {
        return;
    }
 
    uint32_t*   device = fDevice.writable_addr32(x, y);
    uint32_t    color = fPMColor;
    size_t      rowBytes = fDevice.rowBytes();
 
    if (SkGetPackedA32(fPMColor) == 0xFF) {
        SkOpts::rect_memset32(device, color, width, rowBytes, height);
    } else {
        while (height --> 0) {
            SkBlitRow::Color32(device, width, color);
            device = (uint32_t*)((char*)device + rowBytes);
        }
    }
}

blitV()

void SkARGB32_Blitter::blitV ( int  x, int  y, int  height, SkAlpha  alpha  )

overridevirtual

Blit a vertical run of pixels with a constant alpha value.

Reimplemented from SkBlitter.

Definition at line 1622 of file SkBlitter_ARGB32.cpp.

                                                                    {
    if (alpha == 0 || fSrcA == 0) {
        return;
    }
 
    uint32_t* device = fDevice.writable_addr32(x, y);
    uint32_t  color = fPMColor;
 
    if (alpha != 255) {
        color = SkAlphaMulQ(color, SkAlpha255To256(alpha));
    }
 
    unsigned dst_scale = SkAlpha255To256(255 - SkGetPackedA32(color));
    size_t rowBytes = fDevice.rowBytes();
    while (--height >= 0) {
        device[0] = color + SkAlphaMulQ(device[0], dst_scale);
        device = (uint32_t*)((char*)device + rowBytes);
    }
}

Member Data Documentation

fColor

SkColor SkARGB32_Blitter::fColor

protected

Definition at line 78 of file SkCoreBlitters.h.

fPMColor

SkPMColor SkARGB32_Blitter::fPMColor

protected

Definition at line 79 of file SkCoreBlitters.h.

---

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

• third_party/skia/src/core/SkCoreBlitters.h
• third_party/skia/src/core/SkBlitter_ARGB32.cpp