Inheritance diagram for SkWuffsCodec:

Public Member Functions
	SkWuffsCodec (SkEncodedInfo &&encodedInfo, std::unique_ptr< SkStream > stream, bool canSeek, std::unique_ptr< wuffs_gif__decoder, decltype(&sk_free)> dec, std::unique_ptr< uint8_t, decltype(&sk_free)> workbuf_ptr, size_t workbuf_len, wuffs_base__image_config imgcfg, wuffs_base__io_buffer iobuf)

const SkWuffsFrame *	frame (int i) const

std::unique_ptr< SkStream >	getEncodedData () const 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

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 ()

Private Member Functions
SkEncodedImageFormat	onGetEncodedFormat () const override

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

const SkFrameHolder *	getFrameHolder () const override

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

Result	onIncrementalDecode (int *rowsDecoded) override

int	onGetFrameCount () override

bool	onGetFrameInfo (int, FrameInfo *) const override

int	onGetRepetitionCount () 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 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 ))

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 SkScalingCodec
	SkScalingCodec (SkEncodedInfo &&info, XformFormat srcFormat, std::unique_ptr< SkStream > stream, SkEncodedOrigin origin=kTopLeft_SkEncodedOrigin)

SkISize	onGetScaledDimensions (float desiredScale) const override

bool	onDimensionsSupported (const SkISize &requested) 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 bool	onQueryYUVAInfo (const SkYUVAPixmapInfo::SupportedDataTypes &, SkYUVAPixmapInfo *) const

virtual Result	onGetYUVAPlanes (const SkYUVAPixmaps &)

virtual bool	onGetValidSubset (SkIRect *) const

bool	rewindIfNeeded ()

virtual bool	onRewind ()

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

Detailed Description

Definition at line 237 of file SkWuffsCodec.cpp.

Constructor & Destructor Documentation

◆ SkWuffsCodec()

SkWuffsCodec::SkWuffsCodec	(	SkEncodedInfo &&	encodedInfo,
		std::unique_ptr< SkStream >	stream,
		bool	canSeek,
		std::unique_ptr< wuffs_gif__decoder, decltype(&sk_free)>	dec,
		std::unique_ptr< uint8_t, decltype(&sk_free)>	workbuf_ptr,
		size_t	workbuf_len,
		wuffs_base__image_config	imgcfg,
		wuffs_base__io_buffer	iobuf
	)

Definition at line 380 of file SkWuffsCodec.cpp.

    : INHERITED(std::move(encodedInfo),
                skcms_PixelFormat_RGBA_8888,
                // Pass a nullptr SkStream to the SkCodec constructor. We
                // manage the stream ourselves, as the default SkCodec behavior
                // is too trigger-happy on rewinding the stream.
                nullptr),
      fFrameHolder(),
      fPrivStream(std::move(stream)),
      fWorkbufPtr(std::move(workbuf_ptr)),
      fWorkbufLen(workbuf_len),
      fDecoder(std::move(dec)),
      fFirstFrameIOPosition(imgcfg.first_frame_io_position()),
      fFrameConfig(wuffs_base__null_frame_config()),
      fPixelConfig(imgcfg.pixcfg),
      fPixelBuffer(wuffs_base__null_pixel_buffer()),
      fIOBuffer(wuffs_base__empty_io_buffer()),
      fIncrDecDst(nullptr),
      fIncrDecRowBytes(0),
      fIncrDecPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC),
      fIncrDecOnePass(false),
      fFirstCallToIncrementalDecode(false),
      fTwoPassPixbufPtr(nullptr, &sk_free),
      fTwoPassPixbufLen(0),
      fNumFullyReceivedFrames(0),
      fFramesComplete(false),
      fDecoderIsSuspended(false),
      fCanSeek(canSeek) {
    fFrameHolder.init(this, imgcfg.pixcfg.width(), imgcfg.pixcfg.height());
 
    // Initialize fIOBuffer's fields, copying any outstanding data from iobuf to
    // fIOBuffer, as iobuf's backing array may not be valid for the lifetime of
    // this SkWuffsCodec object, but fIOBuffer's backing array (fBuffer) is.
    SkASSERT(iobuf.data.len == SK_WUFFS_CODEC_BUFFER_SIZE);
    memmove(fBuffer, iobuf.data.ptr, iobuf.meta.wi);
    fIOBuffer.data = wuffs_base__make_slice_u8(fBuffer, SK_WUFFS_CODEC_BUFFER_SIZE);
    fIOBuffer.meta = iobuf.meta;
}

Member Function Documentation

◆ frame()

const SkWuffsFrame * SkWuffsCodec::frame ( int i ) const

Definition at line 426 of file SkWuffsCodec.cpp.

                                                   {
    if ((0 <= i) && (static_cast<size_t>(i) < fFrames.size())) {
        return &fFrames[i];
    }
    return nullptr;
}

◆ getEncodedData()

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

overridevirtual

Return the underlying encoded data stream. This may be nullptr if the original stream could not be duplicated.

Reimplemented from SkCodec.

Definition at line 970 of file SkWuffsCodec.cpp.

                                                           {
    SkASSERT(fPrivStream);
    return fPrivStream->duplicate();
}

◆ getFrameHolder()

const SkFrameHolder * SkWuffsCodec::getFrameHolder ( ) const

overrideprivatevirtual

For multi-framed images, return the object with information about the frames.

Reimplemented from SkCodec.

Definition at line 449 of file SkWuffsCodec.cpp.

                                                        {
    return &fFrameHolder;
}

◆ onGetEncodedFormat()

SkEncodedImageFormat SkWuffsCodec::onGetEncodedFormat ( ) const

overrideprivatevirtual

Implements SkCodec.

Definition at line 433 of file SkWuffsCodec.cpp.

                                                            {
    return SkEncodedImageFormat::kGIF;
}

◆ onGetFrameCount()

int SkWuffsCodec::onGetFrameCount ( )

overrideprivatevirtual

Reimplemented from SkCodec.

Definition at line 780 of file SkWuffsCodec.cpp.

                                  {
    if (!fCanSeek) {
        return 1;
    }
 
    // It is valid, in terms of the SkCodec API, to call SkCodec::getFrameCount
    // while in an incremental decode (after onStartIncrementalDecode returns
    // and before onIncrementalDecode returns kSuccess).
    //
    // We should not advance the SkWuffsCodec' stream while doing so, even
    // though other SkCodec implementations can return increasing values from
    // onGetFrameCount when given more data. If we tried to do so, the
    // subsequent resume of the incremental decode would continue reading from
    // a different position in the I/O stream, leading to an incorrect error.
    //
    // Other SkCodec implementations can move the stream forward during
    // onGetFrameCount because they assume that the stream is rewindable /
    // seekable. For example, an alternative GIF implementation may choose to
    // store, for each frame walked past when merely counting the number of
    // frames, the I/O position of each of the frame's GIF data blocks. (A GIF
    // frame's compressed data can have multiple data blocks, each at most 255
    // bytes in length). Obviously, this can require O(numberOfFrames) extra
    // memory to store these I/O positions. The constant factor is small, but
    // it's still O(N), not O(1).
    //
    // Wuffs and SkWuffsCodec try to minimize relying on the rewindable /
    // seekable assumption. By design, Wuffs per se aims for O(1) memory use
    // (after any pixel buffers are allocated) instead of O(N), and its I/O
    // type, wuffs_base__io_buffer, is not necessarily rewindable or seekable.
    //
    // The Wuffs API provides a limited, optional form of seeking, to the start
    // of an animation frame's data, but does not provide arbitrary save and
    // load of its internal state whilst in the middle of an animation frame.
    bool incrementalDecodeIsInProgress = fIncrDecDst != nullptr;
 
    if (!fFramesComplete && !incrementalDecodeIsInProgress) {
        this->onGetFrameCountInternal();
        this->updateNumFullyReceivedFrames();
    }
    return fFrames.size();
}

◆ onGetFrameInfo()

bool SkWuffsCodec::onGetFrameInfo	(	int	i,
		SkCodec::FrameInfo *	frameInfo
	)		const

overrideprivatevirtual

Reimplemented from SkCodec.

Definition at line 852 of file SkWuffsCodec.cpp.

                                                                          {
    if (!fCanSeek) {
        // We haven't read forward in the stream, so this info isn't available.
        return false;
    }
 
    const SkWuffsFrame* f = this->frame(i);
    if (!f) {
        return false;
    }
    if (frameInfo) {
        f->fillIn(frameInfo, static_cast<uint64_t>(i) < this->fNumFullyReceivedFrames);
    }
    return true;
}

◆ onGetPixels()

SkCodec::Result SkWuffsCodec::onGetPixels	(	const SkImageInfo &	info,
		void *	pixels,
		size_t	rowBytes,
		const Options &	,
		int *	rowsDecoded
	)

overrideprivatevirtual

Parameters

rowsDecoded When the encoded image stream is incomplete, this function will return kIncompleteInput and rowsDecoded will be set to the number of scanlines that were successfully decoded. This will allow getPixels() to fill the uninitialized memory.

Implements SkCodec.

Definition at line 437 of file SkWuffsCodec.cpp.

                                                                          {
    SkCodec::Result result = this->onStartIncrementalDecode(dstInfo, dst, rowBytes, options);
    if (result != kSuccess) {
        return result;
    }
    return this->onIncrementalDecode(rowsDecoded);
}

◆ onGetRepetitionCount()

int SkWuffsCodec::onGetRepetitionCount ( )

overrideprivatevirtual

Reimplemented from SkCodec.

Definition at line 868 of file SkWuffsCodec.cpp.

                                       {
    // Convert from Wuffs's loop count to Skia's repeat count. Wuffs' uint32_t
    // number is how many times to play the loop. Skia's int number is how many
    // times to play the loop *after the first play*. Wuffs and Skia use 0 and
    // kRepetitionCountInfinite respectively to mean loop forever.
    uint32_t n = fDecoder->num_animation_loops();
    if (n == 0) {
        return SkCodec::kRepetitionCountInfinite;
    }
    n--;
    return n < INT_MAX ? n : INT_MAX;
}

◆ onIncrementalDecode()

SkCodec::Result SkWuffsCodec::onIncrementalDecode ( int * rowsDecoded )

overrideprivatevirtual

Reimplemented from SkCodec.

Definition at line 610 of file SkWuffsCodec.cpp.

                                                                {
    if (!fIncrDecDst) {
        return SkCodec::kInternalError;
    }
 
    if (rowsDecoded) {
        *rowsDecoded = dstInfo().height();
    }
 
    SkCodec::Result result =
        fIncrDecOnePass ? this->onIncrementalDecodeOnePass() : this->onIncrementalDecodeTwoPass();
    if (result == SkCodec::kSuccess) {
        fIncrDecDst = nullptr;
        fIncrDecRowBytes = 0;
        fIncrDecPixelBlend = WUFFS_BASE__PIXEL_BLEND__SRC;
        fIncrDecOnePass = false;
    }
    return result;
}

◆ onStartIncrementalDecode()

SkCodec::Result SkWuffsCodec::onStartIncrementalDecode	(	const SkImageInfo &	dstInfo,
		void *	dst,
		size_t	rowBytes,
		const SkCodec::Options &	options
	)

overrideprivatevirtual

Reimplemented from SkCodec.

Definition at line 453 of file SkWuffsCodec.cpp.

                                                                                      {
    if (!dst) {
        return SkCodec::kInvalidParameters;
    }
    if (options.fSubset) {
        return SkCodec::kUnimplemented;
    }
    SkCodec::Result result = this->seekFrame(options.fFrameIndex);
    if (result != SkCodec::kSuccess) {
        return result;
    }
 
    const char* status = this->decodeFrameConfig();
    if (status == wuffs_base__suspension__short_read) {
        return SkCodec::kIncompleteInput;
    } else if (status != nullptr) {
        SkCodecPrintf("decodeFrameConfig: %s", status);
        return SkCodec::kErrorInInput;
    }
 
    uint32_t pixelFormat = WUFFS_BASE__PIXEL_FORMAT__INVALID;
    size_t   bytesPerPixel = 0;
 
    switch (dstInfo.colorType()) {
        case kRGB_565_SkColorType:
            pixelFormat = WUFFS_BASE__PIXEL_FORMAT__BGR_565;
            bytesPerPixel = 2;
            break;
        case kBGRA_8888_SkColorType:
            pixelFormat = WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL;
            bytesPerPixel = 4;
            break;
        case kRGBA_8888_SkColorType:
            pixelFormat = WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL;
            bytesPerPixel = 4;
            break;
        default:
            break;
    }
 
    // We can use "one pass" decoding if we have a Skia pixel format that Wuffs
    // supports...
    fIncrDecOnePass = (pixelFormat != WUFFS_BASE__PIXEL_FORMAT__INVALID) &&
                      // ...and no color profile (as Wuffs does not support them)...
                      (!getEncodedInfo().profile()) &&
                      // ...and we use the identity transform (as Wuffs does
                      // not support scaling).
                      (this->dimensions() == dstInfo.dimensions());
 
    result = fIncrDecOnePass ? this->onStartIncrementalDecodeOnePass(
                                   dstInfo, static_cast<uint8_t*>(dst), rowBytes, options,
                                   pixelFormat, bytesPerPixel)
                             : this->onStartIncrementalDecodeTwoPass();
    if (result != SkCodec::kSuccess) {
        return result;
    }
 
    fIncrDecDst = static_cast<uint8_t*>(dst);
    fIncrDecRowBytes = rowBytes;
    fFirstCallToIncrementalDecode = true;
    return SkCodec::kSuccess;
}

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

third_party/skia/src/codec/SkWuffsCodec.cpp

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkWuffsCodec()

Member Function Documentation

◆ frame()

◆ getEncodedData()

◆ getFrameHolder()

◆ onGetEncodedFormat()

◆ onGetFrameCount()

◆ onGetFrameInfo()

◆ onGetPixels()

◆ onGetRepetitionCount()

◆ onIncrementalDecode()

◆ onStartIncrementalDecode()