SkMaskSwizzler Class Reference

#include <SkMaskSwizzler.h>

Inheritance diagram for SkMaskSwizzler:

Public Member Functions
void	swizzle (void *dst, const uint8_t *SK_RESTRICT src)
int	fillWidth () const override
int	swizzleWidth () const
Public Member Functions inherited from SkSampler
int	setSampleX (int sampleX)
void	setSampleY (int sampleY)
int	sampleY () const
bool	rowNeeded (int row) const
	SkSampler ()
virtual	~SkSampler ()
Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default
	SkNoncopyable (SkNoncopyable &&)=default
SkNoncopyable &	operator= (SkNoncopyable &&)=default

Static Public Member Functions
static SkMaskSwizzler *	CreateMaskSwizzler (const SkImageInfo &dstInfo, bool srcIsOpaque, SkMasks *masks, uint32_t bitsPerPixel, const SkCodec::Options &options)
Static Public Member Functions inherited from SkSampler
static void	Fill (const SkImageInfo &info, void *dst, size_t rowBytes, SkCodec::ZeroInitialized zeroInit)

Private Member Functions
int	onSetSampleX (int) override

Detailed Description

Definition at line 25 of file SkMaskSwizzler.h.

Member Function Documentation

CreateMaskSwizzler()

SkMaskSwizzler * SkMaskSwizzler::CreateMaskSwizzler ( const SkImageInfo &  dstInfo, bool  srcIsOpaque, SkMasks *  masks, uint32_t  bitsPerPixel, const SkCodec::Options &  options  )

static

Definition at line 394 of file SkMaskSwizzler.cpp.

                                       {
 
    // Choose the appropriate row procedure
    RowProc proc = nullptr;
    switch (bitsPerPixel) {
        case 16:
            switch (dstInfo.colorType()) {
                case kRGBA_8888_SkColorType:
                    if (srcIsOpaque) {
                        proc = &swizzle_mask16_to_rgba_opaque;
                    } else {
                        switch (dstInfo.alphaType()) {
                            case kUnpremul_SkAlphaType:
                                proc = &swizzle_mask16_to_rgba_unpremul;
                                break;
                            case kPremul_SkAlphaType:
                                proc = &swizzle_mask16_to_rgba_premul;
                                break;
                            default:
                                break;
                        }
                    }
                    break;
                case kBGRA_8888_SkColorType:
                    if (srcIsOpaque) {
                        proc = &swizzle_mask16_to_bgra_opaque;
                    } else {
                        switch (dstInfo.alphaType()) {
                            case kUnpremul_SkAlphaType:
                                proc = &swizzle_mask16_to_bgra_unpremul;
                                break;
                            case kPremul_SkAlphaType:
                                proc = &swizzle_mask16_to_bgra_premul;
                                break;
                            default:
                                break;
                        }
                    }
                    break;
                case kRGB_565_SkColorType:
                    proc = &swizzle_mask16_to_565;
                    break;
                default:
                    break;
            }
            break;
        case 24:
            switch (dstInfo.colorType()) {
                case kRGBA_8888_SkColorType:
                    if (srcIsOpaque) {
                        proc = &swizzle_mask24_to_rgba_opaque;
                    } else {
                        switch (dstInfo.alphaType()) {
                            case kUnpremul_SkAlphaType:
                                proc = &swizzle_mask24_to_rgba_unpremul;
                                break;
                            case kPremul_SkAlphaType:
                                proc = &swizzle_mask24_to_rgba_premul;
                                break;
                            default:
                                break;
                        }
                    }
                    break;
                case kBGRA_8888_SkColorType:
                    if (srcIsOpaque) {
                        proc = &swizzle_mask24_to_bgra_opaque;
                    } else {
                        switch (dstInfo.alphaType()) {
                            case kUnpremul_SkAlphaType:
                                proc = &swizzle_mask24_to_bgra_unpremul;
                                break;
                            case kPremul_SkAlphaType:
                                proc = &swizzle_mask24_to_bgra_premul;
                                break;
                            default:
                                break;
                        }
                    }
                    break;
                case kRGB_565_SkColorType:
                    proc = &swizzle_mask24_to_565;
                    break;
                default:
                    break;
            }
            break;
        case 32:
            switch (dstInfo.colorType()) {
                case kRGBA_8888_SkColorType:
                    if (srcIsOpaque) {
                        proc = &swizzle_mask32_to_rgba_opaque;
                    } else {
                        switch (dstInfo.alphaType()) {
                            case kUnpremul_SkAlphaType:
                                proc = &swizzle_mask32_to_rgba_unpremul;
                                break;
                            case kPremul_SkAlphaType:
                                proc = &swizzle_mask32_to_rgba_premul;
                                break;
                            default:
                                break;
                        }
                    }
                    break;
                case kBGRA_8888_SkColorType:
                    if (srcIsOpaque) {
                        proc = &swizzle_mask32_to_bgra_opaque;
                    } else {
                        switch (dstInfo.alphaType()) {
                            case kUnpremul_SkAlphaType:
                                proc = &swizzle_mask32_to_bgra_unpremul;
                                break;
                            case kPremul_SkAlphaType:
                                proc = &swizzle_mask32_to_bgra_premul;
                                break;
                            default:
                                break;
                        }
                    }
                    break;
                case kRGB_565_SkColorType:
                    proc = &swizzle_mask32_to_565;
                    break;
                default:
                    break;
            }
            break;
        default:
            SkASSERT(false);
            return nullptr;
    }
 
    int srcOffset = 0;
    int srcWidth = dstInfo.width();
    if (options.fSubset) {
        srcOffset = options.fSubset->left();
        srcWidth = options.fSubset->width();
    }
 
    return new SkMaskSwizzler(masks, proc, srcOffset, srcWidth);
}

fillWidth()

int SkMaskSwizzler::fillWidth ( ) const

inlineoverridevirtual

Implements SkSampler.

Definition at line 42 of file SkMaskSwizzler.h.

                                   {
        return fDstWidth;
    }

onSetSampleX()

int SkMaskSwizzler::onSetSampleX ( int  sampleX )

overrideprivatevirtual

Implements SkSampler.

Definition at line 554 of file SkMaskSwizzler.cpp.

                                            {
    // FIXME: Share this function with SkSwizzler?
    SkASSERT(sampleX > 0); // Surely there is an upper limit? Should there be
                           // way to report failure?
    fSampleX = sampleX;
    fX0 = get_start_coord(sampleX) + fSrcOffset;
    fDstWidth = get_scaled_dimension(fSubsetWidth, sampleX);
 
    // check that fX0 is valid
    SkASSERT(fX0 >= 0);
    return fDstWidth;
}

swizzle()

void SkMaskSwizzler::swizzle	(	void *	dst,
		const uint8_t *SK_RESTRICT	src
	)

Definition at line 572 of file SkMaskSwizzler.cpp.

                                                                      {
    SkASSERT(nullptr != dst && nullptr != src);
    fRowProc(dst, src, fDstWidth, fMasks, fX0, fSampleX);
}

swizzleWidth()

int SkMaskSwizzler::swizzleWidth ( ) const

inline

Returns the byte offset at which we write to destination memory, taking scaling, subsetting, and partial frames into account. A similar function exists on SkSwizzler.

Definition at line 51 of file SkMaskSwizzler.h.

{ return fDstWidth; }

---

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

• third_party/skia/src/codec/SkMaskSwizzler.h
• third_party/skia/src/codec/SkMaskSwizzler.cpp