Inheritance diagram for SkPngInterlacedDecoder:

Public Member Functions
	SkPngInterlacedDecoder (SkEncodedInfo &&info, std::unique_ptr< SkStream > stream, SkPngChunkReader *reader, png_structp png_ptr, png_infop info_ptr, int bitDepth, int numberPasses)

Public Member Functions inherited from SkPngCodec
void	setIdatLength (size_t len)

	~SkPngCodec () override

Public Member Functions inherited from SkCodec
virtual	~SkCodec ()

SkImageInfo	getInfo () const

SkISize	dimensions () const

SkIRect	bounds () const

const skcms_ICCProfile *	getICCProfile () const

SkEncodedOrigin	getOrigin () const

SkISize	getScaledDimensions (float desiredScale) const

bool	getValidSubset (SkIRect *desiredSubset) const

SkEncodedImageFormat	getEncodedFormat () const

virtual std::unique_ptr< SkStream >	getEncodedData () const

Result	getPixels (const SkImageInfo &info, void pixels, size_t rowBytes, const Options )

Result	getPixels (const SkImageInfo &info, void *pixels, size_t rowBytes)

Result	getPixels (const SkPixmap &pm, const Options *opts=nullptr)

std::tuple< sk_sp< SkImage >, SkCodec::Result >	getImage (const SkImageInfo &info, const Options *opts=nullptr)

std::tuple< sk_sp< SkImage >, SkCodec::Result >	getImage ()

bool	queryYUVAInfo (const SkYUVAPixmapInfo::SupportedDataTypes &supportedDataTypes, SkYUVAPixmapInfo *yuvaPixmapInfo) const

Result	getYUVAPlanes (const SkYUVAPixmaps &yuvaPixmaps)

Result	startIncrementalDecode (const SkImageInfo &dstInfo, void dst, size_t rowBytes, const Options )

Result	startIncrementalDecode (const SkImageInfo &dstInfo, void *dst, size_t rowBytes)

Result	incrementalDecode (int *rowsDecoded=nullptr)

Result	startScanlineDecode (const SkImageInfo &dstInfo, const Options *options)

Result	startScanlineDecode (const SkImageInfo &dstInfo)

int	getScanlines (void *dst, int countLines, size_t rowBytes)

bool	skipScanlines (int countLines)

SkScanlineOrder	getScanlineOrder () const

int	nextScanline () const

int	outputScanline (int inputScanline) const

int	getFrameCount ()

bool	getFrameInfo (int index, FrameInfo *info) const

std::vector< FrameInfo >	getFrameInfo ()

int	getRepetitionCount ()

Static Public Member Functions
static void	InterlacedRowCallback (png_structp png_ptr, png_bytep row, png_uint_32 rowNum, int pass)

Static Public Member Functions inherited from SkPngCodec
static bool	IsPng (const void *, size_t)

static std::unique_ptr< SkCodec >	MakeFromStream (std::unique_ptr< SkStream >, Result , SkPngChunkReader =nullptr)

Static Public Member Functions inherited from SkCodec
static constexpr size_t	MinBufferedBytesNeeded ()

static const char *	ResultToString (Result)

static std::unique_ptr< SkCodec >	MakeFromStream (std::unique_ptr< SkStream >, SkSpan< const SkCodecs::Decoder > decoders, Result =nullptr, SkPngChunkReader =nullptr, SelectionPolicy selectionPolicy=SelectionPolicy::kPreferStillImage)

static std::unique_ptr< SkCodec >	MakeFromStream (std::unique_ptr< SkStream >, Result =nullptr, SkPngChunkReader =nullptr, SelectionPolicy selectionPolicy=SelectionPolicy::kPreferStillImage)

static std::unique_ptr< SkCodec >	MakeFromData (sk_sp< SkData >, SkSpan< const SkCodecs::Decoder > decoders, SkPngChunkReader *=nullptr)

static std::unique_ptr< SkCodec >	MakeFromData (sk_sp< SkData >, SkPngChunkReader *=nullptr)

static void	Register (bool(peek)(const void , size_t), std::unique_ptr< SkCodec >(make)(std::unique_ptr< SkStream >, SkCodec::Result ))

Private Member Functions
Result	decodeAllRows (void dst, size_t rowBytes, int rowsDecoded) override

void	setRange (int firstRow, int lastRow, void *dst, size_t rowBytes) override

Result	decode (int *rowsDecoded) override

Additional Inherited Members
Public Types inherited from SkCodec
enum	Result { kSuccess , kIncompleteInput , kErrorInInput , kInvalidConversion , kInvalidScale , kInvalidParameters , kInvalidInput , kCouldNotRewind , kInternalError , kUnimplemented }

enum class	SelectionPolicy { kPreferStillImage , kPreferAnimation }

enum	ZeroInitialized { kYes_ZeroInitialized , kNo_ZeroInitialized }

enum	SkScanlineOrder { kTopDown_SkScanlineOrder , kBottomUp_SkScanlineOrder }

Static Public Attributes inherited from SkCodec
static constexpr int	kNoFrame = -1

static constexpr int	kRepetitionCountInfinite = -1

Protected Types inherited from SkCodec
using	XformFormat = skcms_PixelFormat

Protected Member Functions inherited from SkPngCodec
	SkPngCodec (SkEncodedInfo &&, std::unique_ptr< SkStream >, SkPngChunkReader , void png_ptr, void *info_ptr, int bitDepth)

Result	onGetPixels (const SkImageInfo &, void , size_t, const Options &, int ) override

SkEncodedImageFormat	onGetEncodedFormat () const override

bool	onRewind () override

SkSampler *	getSampler (bool createIfNecessary) override

void	applyXformRow (void dst, const void src)

voidp	png_ptr ()

voidp	info_ptr ()

SkSwizzler *	swizzler ()

void	initializeXformParams ()

bool	processData ()

Result	onStartIncrementalDecode (const SkImageInfo &dstInfo, void *pixels, size_t rowBytes, const SkCodec::Options &) override

Result	onIncrementalDecode (int *) override

Protected Member Functions inherited from SkCodec
const SkEncodedInfo &	getEncodedInfo () const

	SkCodec (SkEncodedInfo &&, XformFormat srcFormat, std::unique_ptr< SkStream >, SkEncodedOrigin=kTopLeft_SkEncodedOrigin)

void	setSrcXformFormat (XformFormat pixelFormat)

XformFormat	getSrcXformFormat () const

virtual bool	onGetGainmapInfo (SkGainmapInfo , std::unique_ptr< SkStream > )

virtual SkISize	onGetScaledDimensions (float) const

virtual bool	onDimensionsSupported (const SkISize &)

virtual bool	onQueryYUVAInfo (const SkYUVAPixmapInfo::SupportedDataTypes &, SkYUVAPixmapInfo *) const

virtual Result	onGetYUVAPlanes (const SkYUVAPixmaps &)

virtual bool	onGetValidSubset (SkIRect *) const

bool	rewindIfNeeded ()

SkStream *	stream ()

virtual SkScanlineOrder	onGetScanlineOrder () const

const SkImageInfo &	dstInfo () const

const Options &	options () const

int	currScanline () const

virtual int	onOutputScanline (int inputScanline) const

virtual bool	conversionSupported (const SkImageInfo &dst, bool srcIsOpaque, bool needsColorXform)

virtual bool	usesColorXform () const

void	applyColorXform (void dst, const void src, int count) const

bool	colorXform () const

bool	xformOnDecode () const

virtual int	onGetFrameCount ()

virtual bool	onGetFrameInfo (int, FrameInfo *) const

virtual int	onGetRepetitionCount ()

Protected Attributes inherited from SkPngCodec
sk_sp< SkPngChunkReader >	fPngChunkReader

voidp	fPng_ptr

voidp	fInfo_ptr

sk_sp< SkColorPalette >	fColorTable

std::unique_ptr< SkSwizzler >	fSwizzler

skia_private::AutoTMalloc< uint8_t >	fStorage

void *	fColorXformSrcRow

const int	fBitDepth

Detailed Description

Definition at line 625 of file SkPngCodec.cpp.

Constructor & Destructor Documentation

◆ SkPngInterlacedDecoder()

SkPngInterlacedDecoder::SkPngInterlacedDecoder	(	SkEncodedInfo &&	info,
		std::unique_ptr< SkStream >	stream,
		SkPngChunkReader *	reader,
		png_structp	png_ptr,
		png_infop	info_ptr,
		int	bitDepth,
		int	numberPasses
	)

inline

Definition at line 627 of file SkPngCodec.cpp.

        : INHERITED(std::move(info), std::move(stream), reader, png_ptr, info_ptr, bitDepth)
        , fNumberPasses(numberPasses)
        , fFirstRow(0)
        , fLastRow(0)
        , fLinesDecoded(0)
        , fInterlacedComplete(false)
        , fPng_rowbytes(0)
    {}

Member Function Documentation

◆ decode()

Result SkPngInterlacedDecoder::decode ( int * rowsDecoded )

inlineoverrideprivatevirtual

Implements SkPngCodec.

Definition at line 731 of file SkPngCodec.cpp.

                                             {
        const bool success = this->processData();
 
        // Now apply Xforms on all the rows that were decoded.
        if (!fLinesDecoded) {
            if (rowsDecoded) {
                *rowsDecoded = 0;
            }
            return log_and_return_error(success);
        }
 
        const int sampleY = this->swizzler() ? this->swizzler()->sampleY() : 1;
        const int rowsNeeded = get_scaled_dimension(fLastRow - fFirstRow + 1, sampleY);
 
        // FIXME: For resuming interlace, we may swizzle a row that hasn't changed. But it
        // may be too tricky/expensive to handle that correctly.
 
        // Offset srcRow by get_start_coord rows. We do not need to account for fFirstRow,
        // since the first row in fInterlaceBuffer corresponds to fFirstRow.
        int srcRow = get_start_coord(sampleY);
        void* dst = fDst;
        int rowsWrittenToOutput = 0;
        while (rowsWrittenToOutput < rowsNeeded && srcRow < fLinesDecoded) {
            png_bytep src = SkTAddOffset<png_byte>(fInterlaceBuffer.get(), fPng_rowbytes * srcRow);
            this->applyXformRow(dst, src);
            dst = SkTAddOffset<void>(dst, fRowBytes);
 
            rowsWrittenToOutput++;
            srcRow += sampleY;
        }
 
        if (success && fInterlacedComplete) {
            return kSuccess;
        }
 
        if (rowsDecoded) {
            *rowsDecoded = rowsWrittenToOutput;
        }
        return log_and_return_error(success);
    }

◆ decodeAllRows()

Result SkPngInterlacedDecoder::decodeAllRows	(	void *	dst,
		size_t	rowBytes,
		int *	rowsDecoded
	)

inlineoverrideprivatevirtual

Implements SkPngCodec.

Definition at line 691 of file SkPngCodec.cpp.

                                                                                {
        const int height = this->dimensions().height();
        this->setUpInterlaceBuffer(height);
        png_set_progressive_read_fn(this->png_ptr(), this, nullptr, InterlacedRowCallback,
                                    nullptr);
 
        fFirstRow = 0;
        fLastRow = height - 1;
        fLinesDecoded = 0;
 
        const bool success = this->processData();
        png_bytep srcRow = fInterlaceBuffer.get();
        // FIXME: When resuming, this may rewrite rows that did not change.
        for (int rowNum = 0; rowNum < fLinesDecoded; rowNum++) {
            this->applyXformRow(dst, srcRow);
            dst = SkTAddOffset<void>(dst, rowBytes);
            srcRow = SkTAddOffset<png_byte>(srcRow, fPng_rowbytes);
        }
        if (success && fInterlacedComplete) {
            return kSuccess;
        }
 
        if (rowsDecoded) {
            *rowsDecoded = fLinesDecoded;
        }
 
        return log_and_return_error(success);
    }

◆ InterlacedRowCallback()

static void SkPngInterlacedDecoder::InterlacedRowCallback	(	png_structp	png_ptr,
		png_bytep	row,
		png_uint_32	rowNum,
		int	pass
	)

inlinestatic

Definition at line 639 of file SkPngCodec.cpp.

                                                                                                        {
        auto decoder = static_cast<SkPngInterlacedDecoder*>(png_get_progressive_ptr(png_ptr));
        decoder->interlacedRowCallback(row, rowNum, pass);
    }

◆ setRange()

void SkPngInterlacedDecoder::setRange	(	int	firstRow,
		int	lastRow,
		void *	dst,
		size_t	rowBytes
	)

inlineoverrideprivatevirtual

Implements SkPngCodec.

Definition at line 720 of file SkPngCodec.cpp.

                                                                                  {
        // FIXME: We could skip rows in the interlace buffer that we won't put in the output.
        this->setUpInterlaceBuffer(lastRow - firstRow + 1);
        png_set_progressive_read_fn(this->png_ptr(), this, nullptr, InterlacedRowCallback, nullptr);
        fFirstRow = firstRow;
        fLastRow = lastRow;
        fDst = dst;
        fRowBytes = rowBytes;
        fLinesDecoded = 0;
    }

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

third_party/skia/src/codec/SkPngCodec.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkPngInterlacedDecoder()

Member Function Documentation

◆ decode()

◆ decodeAllRows()

◆ InterlacedRowCallback()

◆ setRange()