SkSwizzler Class Reference

#include <SkSwizzler.h>

Inheritance diagram for SkSwizzler:

Public Member Functions
void	swizzle (void *dst, const uint8_t *SK_RESTRICT src)
int	fillWidth () const override
int	sampleX () const
int	swizzleWidth () const
size_t	swizzleOffsetBytes () 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 std::unique_ptr< SkSwizzler >	Make (const SkEncodedInfo &encodedInfo, const SkPMColor *ctable, const SkImageInfo &dstInfo, const SkCodec::Options &, const SkIRect *frame=nullptr)
static std::unique_ptr< SkSwizzler >	MakeSimple (int srcBPP, const SkImageInfo &dstInfo, const SkCodec::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 24 of file SkSwizzler.h.

Member Function Documentation

fillWidth()

int SkSwizzler::fillWidth ( ) const

inlineoverridevirtual

Implements SkSampler.

Definition at line 72 of file SkSwizzler.h.

                                   {
        return fAllocatedWidth;
    }

Make()

std::unique_ptr< SkSwizzler > SkSwizzler::Make ( const SkEncodedInfo &  encodedInfo, const SkPMColor *  ctable, const SkImageInfo &  dstInfo, const SkCodec::Options &  options, const SkIRect *  frame = nullptr  )

static

Create a new SkSwizzler.

Parameters

encodedInfo	Description of the format of the encoded data.
ctable	Unowned pointer to an array of up to 256 colors for an index source.
dstInfo	Describes the destination.
options	Contains partial scanline information and whether the dst is zero- initialized.
frame	Is non-NULL if the source pixels are part of an image frame that is a subset of the full image.

Note that a deeper discussion of partial scanline subsets and image frame subsets is below. Currently, we do not support both simultaneously. If options->fSubset is non-NULL, frame must be NULL.

Returns

A new SkSwizzler or nullptr on failure.

Definition at line 821 of file SkSwizzler.cpp.

                                                                   {
    if (SkEncodedInfo::kPalette_Color == encodedInfo.color() && nullptr == ctable) {
        return nullptr;
    }
 
    RowProc fastProc = nullptr;
    RowProc proc = nullptr;
    SkCodec::ZeroInitialized zeroInit = options.fZeroInitialized;
    const bool premultiply = (SkEncodedInfo::kOpaque_Alpha != encodedInfo.alpha()) &&
            (kPremul_SkAlphaType == dstInfo.alphaType());
 
    switch (encodedInfo.color()) {
        case SkEncodedInfo::kGray_Color:
            switch (encodedInfo.bitsPerComponent()) {
                case 1:
                    switch (dstInfo.colorType()) {
                        case kRGBA_8888_SkColorType:
                        case kBGRA_8888_SkColorType:
                            proc = &swizzle_bit_to_n32;
                            break;
                        case kRGB_565_SkColorType:
                            proc = &swizzle_bit_to_565;
                            break;
                        case kGray_8_SkColorType:
                            proc = &swizzle_bit_to_grayscale;
                            break;
                        case kRGBA_F16_SkColorType:
                            proc = &swizzle_bit_to_f16;
                            break;
                        default:
                            return nullptr;
                    }
                    break;
                case 8:
                    switch (dstInfo.colorType()) {
                        case kRGBA_8888_SkColorType:
                        case kBGRA_8888_SkColorType:
                            proc = &swizzle_gray_to_n32;
                            fastProc = &fast_swizzle_gray_to_n32;
                            break;
                        case kGray_8_SkColorType:
                            proc = &sample1;
                            fastProc = ©
                            break;
                        case kRGB_565_SkColorType:
                            proc = &swizzle_gray_to_565;
                            break;
                        default:
                            return nullptr;
                    }
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::kXAlpha_Color:
        case SkEncodedInfo::kGrayAlpha_Color:
            switch (dstInfo.colorType()) {
                case kRGBA_8888_SkColorType:
                case kBGRA_8888_SkColorType:
                    if (premultiply) {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeadingGrayAlphaZerosThen
                                    <swizzle_grayalpha_to_n32_premul>;
                            fastProc = &SkipLeadingGrayAlphaZerosThen
                                    <fast_swizzle_grayalpha_to_n32_premul>;
                        } else {
                            proc = &swizzle_grayalpha_to_n32_premul;
                            fastProc = &fast_swizzle_grayalpha_to_n32_premul;
                        }
                    } else {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeadingGrayAlphaZerosThen
                                    <swizzle_grayalpha_to_n32_unpremul>;
                            fastProc = &SkipLeadingGrayAlphaZerosThen
                                    <fast_swizzle_grayalpha_to_n32_unpremul>;
                        } else {
                            proc = &swizzle_grayalpha_to_n32_unpremul;
                            fastProc = &fast_swizzle_grayalpha_to_n32_unpremul;
                        }
                    }
                    break;
                case kAlpha_8_SkColorType:
                    proc = &swizzle_grayalpha_to_a8;
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::kPalette_Color:
            // We assume that the color table is premultiplied and swizzled
            // as desired.
            switch (encodedInfo.bitsPerComponent()) {
                case 1:
                case 2:
                case 4:
                    switch (dstInfo.colorType()) {
                        case kRGBA_8888_SkColorType:
                        case kBGRA_8888_SkColorType:
                            proc = &swizzle_small_index_to_n32;
                            break;
                        case kRGB_565_SkColorType:
                            proc = &swizzle_small_index_to_565;
                            break;
                        default:
                            return nullptr;
                    }
                    break;
                case 8:
                    switch (dstInfo.colorType()) {
                        case kRGBA_8888_SkColorType:
                        case kBGRA_8888_SkColorType:
                        case kBGR_101010x_XR_SkColorType:
                            if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                                proc = &swizzle_index_to_n32_skipZ;
                            } else {
                                proc = &swizzle_index_to_n32;
                            }
                            break;
                        case kRGB_565_SkColorType:
                            proc = &swizzle_index_to_565;
                            break;
                        default:
                            return nullptr;
                    }
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::k565_Color:
            // Treat 565 exactly like RGB (since it's still encoded as 8 bits per component).
            // We just mark as 565 when we have a hint that there are only 5/6/5 "significant"
            // bits in each channel.
        case SkEncodedInfo::kRGB_Color:
            switch (dstInfo.colorType()) {
                case kRGBA_8888_SkColorType:
                    if (16 == encodedInfo.bitsPerComponent()) {
                        proc = &swizzle_rgb16_to_rgba;
                        break;
                    }
 
                    SkASSERT(8 == encodedInfo.bitsPerComponent());
                    proc = &swizzle_rgb_to_rgba;
                    fastProc = &fast_swizzle_rgb_to_rgba;
                    break;
                case kBGRA_8888_SkColorType:
                    if (16 == encodedInfo.bitsPerComponent()) {
                        proc = &swizzle_rgb16_to_bgra;
                        break;
                    }
 
                    SkASSERT(8 == encodedInfo.bitsPerComponent());
                    proc = &swizzle_rgb_to_bgra;
                    fastProc = &fast_swizzle_rgb_to_bgra;
                    break;
                case kRGB_565_SkColorType:
                    if (16 == encodedInfo.bitsPerComponent()) {
                        proc = &swizzle_rgb16_to_565;
                        break;
                    }
 
                    proc = &swizzle_rgb_to_565;
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::kRGBA_Color:
            switch (dstInfo.colorType()) {
                case kRGBA_8888_SkColorType:
                    if (16 == encodedInfo.bitsPerComponent()) {
                        proc = premultiply ? &swizzle_rgba16_to_rgba_premul :
                                             &swizzle_rgba16_to_rgba_unpremul;
                        break;
                    }
 
                    SkASSERT(8 == encodedInfo.bitsPerComponent());
                    if (premultiply) {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_rgba_premul>;
                            fastProc = &SkipLeading8888ZerosThen
                                    <fast_swizzle_rgba_to_rgba_premul>;
                        } else {
                            proc = &swizzle_rgba_to_rgba_premul;
                            fastProc = &fast_swizzle_rgba_to_rgba_premul;
                        }
                    } else {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<sample4>;
                            fastProc = &SkipLeading8888ZerosThen<copy>;
                        } else {
                            proc = &sample4;
                            fastProc = &copy;
                        }
                    }
                    break;
                case kBGRA_8888_SkColorType:
                    if (16 == encodedInfo.bitsPerComponent()) {
                        proc = premultiply ? &swizzle_rgba16_to_bgra_premul :
                                             &swizzle_rgba16_to_bgra_unpremul;
                        break;
                    }
 
                    SkASSERT(8 == encodedInfo.bitsPerComponent());
                    if (premultiply) {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_premul>;
                            fastProc = &SkipLeading8888ZerosThen
                                    <fast_swizzle_rgba_to_bgra_premul>;
                        } else {
                            proc = &swizzle_rgba_to_bgra_premul;
                            fastProc = &fast_swizzle_rgba_to_bgra_premul;
                        }
                    } else {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_unpremul>;
                            fastProc = &SkipLeading8888ZerosThen
                                    <fast_swizzle_rgba_to_bgra_unpremul>;
                        } else {
                            proc = &swizzle_rgba_to_bgra_unpremul;
                            fastProc = &fast_swizzle_rgba_to_bgra_unpremul;
                        }
                    }
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::kBGR_Color:
            switch (dstInfo.colorType()) {
                case kBGRA_8888_SkColorType:
                    proc = &swizzle_rgb_to_rgba;
                    fastProc = &fast_swizzle_rgb_to_rgba;
                    break;
                case kRGBA_8888_SkColorType:
                    proc = &swizzle_rgb_to_bgra;
                    fastProc = &fast_swizzle_rgb_to_bgra;
                    break;
                case kRGB_565_SkColorType:
                    proc = &swizzle_bgr_to_565;
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::kBGRX_Color:
            switch (dstInfo.colorType()) {
                case kBGRA_8888_SkColorType:
                    proc = &swizzle_rgb_to_rgba;
                    break;
                case kRGBA_8888_SkColorType:
                    proc = &swizzle_rgb_to_bgra;
                    break;
                case kRGB_565_SkColorType:
                    proc = &swizzle_bgr_to_565;
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::kBGRA_Color:
            switch (dstInfo.colorType()) {
                case kBGRA_8888_SkColorType:
                    if (premultiply) {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_rgba_premul>;
                            fastProc = &SkipLeading8888ZerosThen
                                    <fast_swizzle_rgba_to_rgba_premul>;
                        } else {
                            proc = &swizzle_rgba_to_rgba_premul;
                            fastProc = &fast_swizzle_rgba_to_rgba_premul;
                        }
                    } else {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<sample4>;
                            fastProc = &SkipLeading8888ZerosThen<copy>;
                        } else {
                            proc = &sample4;
                            fastProc = &copy;
                        }
                    }
                    break;
                case kRGBA_8888_SkColorType:
                    if (premultiply) {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_premul>;
                            fastProc = &SkipLeading8888ZerosThen
                                    <fast_swizzle_rgba_to_bgra_premul>;
                        } else {
                            proc = &swizzle_rgba_to_bgra_premul;
                            fastProc = &fast_swizzle_rgba_to_bgra_premul;
                        }
                    } else {
                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_unpremul>;
                            fastProc = &SkipLeading8888ZerosThen
                                    <fast_swizzle_rgba_to_bgra_unpremul>;
                        } else {
                            proc = &swizzle_rgba_to_bgra_unpremul;
                            fastProc = &fast_swizzle_rgba_to_bgra_unpremul;
                        }
                    }
                    break;
                default:
                    return nullptr;
            }
            break;
        case SkEncodedInfo::kInvertedCMYK_Color:
            switch (dstInfo.colorType()) {
                case kRGBA_8888_SkColorType:
                    proc = &swizzle_cmyk_to_rgba;
                    fastProc = &fast_swizzle_cmyk_to_rgba;
                    break;
                case kBGRA_8888_SkColorType:
                    proc = &swizzle_cmyk_to_bgra;
                    fastProc = &fast_swizzle_cmyk_to_bgra;
                    break;
                case kRGB_565_SkColorType:
                    proc = &swizzle_cmyk_to_565;
                    break;
                default:
                    return nullptr;
            }
            break;
        default:
            return nullptr;
    }
 
    // Store bpp in bytes if it is an even multiple, otherwise use bits
    uint8_t bitsPerPixel = encodedInfo.bitsPerPixel();
    int srcBPP = SkIsAlign8(bitsPerPixel) ? bitsPerPixel / 8 : bitsPerPixel;
    int dstBPP = dstInfo.bytesPerPixel();
    return Make(dstInfo, fastProc, proc, ctable, srcBPP, dstBPP, options, frame);
}

MakeSimple()

std::unique_ptr< SkSwizzler > SkSwizzler::MakeSimple ( int  srcBPP, const SkImageInfo &  dstInfo, const SkCodec::Options &  options  )

static

Create a simplified swizzler that does not need to do format conversion. The swizzler only needs to sample and/or subset.

Parameters

srcBPP	Bytes per pixel of the source.
dstInfo	Describes the destination.
options	Contains partial scanline information and whether the dst is zero- initialized.

Returns

A new SkSwizzler or nullptr on failure.

Definition at line 792 of file SkSwizzler.cpp.

                                                                                  {
    RowProc proc = nullptr;
    switch (srcBPP) {
        case 1:     // kGray_8_SkColorType
            proc = &sample1;
            break;
        case 2:     // kRGB_565_SkColorType
            proc = &sample2;
            break;
        case 4:     // kRGBA_8888_SkColorType
                    // kBGRA_8888_SkColorType
                    // kRGBA_1010102_SkColorType
            proc = &sample4;
            break;
        case 6:     // 16 bit PNG no alpha
            proc = &sample6;
            break;
        case 8:     // 16 bit PNG with alpha
            proc = &sample8;
            break;
        default:
            return nullptr;
    }
 
    return Make(dstInfo, &copy, proc, nullptr /*ctable*/, srcBPP,
                dstInfo.bytesPerPixel(), options, nullptr /*frame*/);
}

onSetSampleX()

int SkSwizzler::onSetSampleX ( int  sampleX )

overrideprivatevirtual

Implements SkSampler.

Definition at line 1203 of file SkSwizzler.cpp.

                                        {
    SkASSERT(sampleX > 0);
 
    fSampleX = sampleX;
    fDstOffsetBytes = (fDstOffset / sampleX) * fDstBPP;
    fSwizzleWidth = get_scaled_dimension(fSrcWidth, sampleX);
    fAllocatedWidth = get_scaled_dimension(fDstWidth, sampleX);
 
    int frameSampleX = sampleX;
    if (fSrcWidth < fDstWidth) {
        // Although SkSampledCodec adjusted sampleX so that it will never be
        // larger than the width of the image (or subset, if applicable), it
        // doesn't account for the width of a subset frame (i.e. gif). As a
        // result, get_start_coord(sampleX) could result in fSrcOffsetUnits
        // being wider than fSrcWidth. Compute a sampling rate based on the
        // frame width to ensure that fSrcOffsetUnits is sensible.
        frameSampleX = fSrcWidth / fSwizzleWidth;
    }
    fSrcOffsetUnits = (get_start_coord(frameSampleX) + fSrcOffset) * fSrcBPP;
 
    if (fDstOffsetBytes > 0) {
        const size_t dstSwizzleBytes   = fSwizzleWidth   * fDstBPP;
        const size_t dstAllocatedBytes = fAllocatedWidth * fDstBPP;
        if (fDstOffsetBytes + dstSwizzleBytes > dstAllocatedBytes) {
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
            SkAndroidFrameworkUtils::SafetyNetLog("118143775");
#endif
            SkASSERT(dstSwizzleBytes <= dstAllocatedBytes);
            fDstOffsetBytes = dstAllocatedBytes - dstSwizzleBytes;
        }
    }
 
    // The optimized swizzler functions do not support sampling.  Sampled swizzles
    // are already fast because they skip pixels.  We haven't seen a situation
    // where speeding up sampling has a significant impact on total decode time.
    if (1 == fSampleX && fFastProc) {
        fActualProc = fFastProc;
    } else {
        fActualProc = fSlowProc;
    }
 
    return fAllocatedWidth;
}

sampleX()

int SkSwizzler::sampleX ( ) const

inline

If fSampleX > 1, the swizzler is sampling every fSampleX'th pixel and discarding the rest.

This getter is currently used by SkBmpStandardCodec for Bmp-in-Ico decodes. Ideally, the subclasses of SkCodec would have no knowledge of sampling, but this allows us to apply a transparency mask to pixels after swizzling.

Definition at line 84 of file SkSwizzler.h.

{ return fSampleX; }

swizzle()

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

Swizzle a line. Generally this will be called height times, once for each row of source. By allowing the caller to pass in the dst pointer, we give the caller flexibility to use the swizzler even when the encoded data does not store the rows in order. This also improves usability for scaled and subset decodes.

Parameters

dst	Where we write the output.
src	The next row of the source data.

Definition at line 1247 of file SkSwizzler.cpp.

                                                                  {
    SkASSERT(nullptr != dst && nullptr != src);
    fActualProc(SkTAddOffset<void>(dst, fDstOffsetBytes), src, fSwizzleWidth, fSrcBPP,
            fSampleX * fSrcBPP, fSrcOffsetUnits, fColorTable);
}

swizzleOffsetBytes()

size_t SkSwizzler::swizzleOffsetBytes ( ) const

inline

Returns the byte offset at which we write to destination memory, taking scaling, subsetting, and partial frames into account.

Definition at line 96 of file SkSwizzler.h.

{ return fDstOffsetBytes; }

swizzleWidth()

int SkSwizzler::swizzleWidth ( ) const

inline

Returns the actual number of pixels written to destination memory, taking scaling, subsetting, and partial frames into account.

Definition at line 90 of file SkSwizzler.h.

{ return fSwizzleWidth; }

---

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

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