#include <SkCodec.h>

Inheritance diagram for SkCodec:

Classes
struct	FrameInfo

struct	Options

Public Types
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 }

Public Member Functions
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 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
static constexpr int	kNoFrame = -1

static constexpr int	kRepetitionCountInfinite = -1

Protected Types
using	XformFormat = skcms_PixelFormat

Protected Member Functions
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 SkEncodedImageFormat	onGetEncodedFormat () const =0

virtual Result	onGetPixels (const SkImageInfo &info, void pixels, size_t rowBytes, const Options &, int rowsDecoded)=0

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

virtual int	onGetFrameCount ()

virtual bool	onGetFrameInfo (int, FrameInfo *) const

virtual int	onGetRepetitionCount ()

Private Member Functions
virtual const SkFrameHolder *	getFrameHolder () const

virtual Result	onStartScanlineDecode (const SkImageInfo &, const Options &)

virtual Result	onStartIncrementalDecode (const SkImageInfo &, void *, size_t, const Options &)

virtual Result	onIncrementalDecode (int *)

virtual bool	onSkipScanlines (int)

virtual int	onGetScanlines (void *, int, size_t)

virtual SkSampler *	getSampler (bool)

Friends
class	DM::CodecSrc

class	PNGCodecGM

class	SkSampledCodec

class	SkIcoCodec

class	SkAndroidCodec

class	SkPDFBitmap

Detailed Description

Abstraction layer directly on top of an image codec.

Definition at line 58 of file SkCodec.h.

Member Typedef Documentation

◆ XformFormat

using SkCodec::XformFormat = skcms_PixelFormat

protected

Definition at line 790 of file SkCodec.h.

Member Enumeration Documentation

◆ Result

enum SkCodec::Result

Error codes for various SkCodec methods.

Enumerator
kSuccess	General return value for success.
kIncompleteInput	The input is incomplete. A partial image was generated.
kErrorInInput	Like kIncompleteInput, except the input had an error. If returned from an incremental decode, decoding cannot continue, even with more data.
kInvalidConversion	The generator cannot convert to match the request, ignoring dimensions.
kInvalidScale	The generator cannot scale to requested size.
kInvalidParameters	Parameters (besides info) are invalid. e.g. NULL pixels, rowBytes too small, etc.
kInvalidInput	The input did not contain a valid image.
kCouldNotRewind	Fulfilling this request requires rewinding the input, which is not supported for this input.
kInternalError	An internal error, such as OOM.
kUnimplemented	This method is not implemented by this codec. FIXME: Perhaps this should be kUnsupported?

Definition at line 76 of file SkCodec.h.

                {
        /**
         *  General return value for success.
         */
        kSuccess,
        /**
         *  The input is incomplete. A partial image was generated.
         */
        kIncompleteInput,
        /**
         *  Like kIncompleteInput, except the input had an error.
         *
         *  If returned from an incremental decode, decoding cannot continue,
         *  even with more data.
         */
        kErrorInInput,
        /**
         *  The generator cannot convert to match the request, ignoring
         *  dimensions.
         */
        kInvalidConversion,
        /**
         *  The generator cannot scale to requested size.
         */
        kInvalidScale,
        /**
         *  Parameters (besides info) are invalid. e.g. NULL pixels, rowBytes
         *  too small, etc.
         */
        kInvalidParameters,
        /**
         *  The input did not contain a valid image.
         */
        kInvalidInput,
        /**
         *  Fulfilling this request requires rewinding the input, which is not
         *  supported for this input.
         */
        kCouldNotRewind,
        /**
         *  An internal error, such as OOM.
         */
        kInternalError,
        /**
         *  This method is not implemented by this codec.
         *  FIXME: Perhaps this should be kUnsupported?
         */
        kUnimplemented,
    };

◆ SelectionPolicy

enum class SkCodec::SelectionPolicy

strong

For container formats that contain both still images and image sequences, instruct the decoder how the output should be selected. (Refer to comments for each value for more details.)

Enumerator
kPreferStillImage	If the container format contains both still images and image sequences, SkCodec should choose one of the still images. This is the default. Note that kPreferStillImage may prevent use of the animation features if the input is not rewindable.
kPreferAnimation	If the container format contains both still images and image sequences, SkCodec should choose one of the image sequences for animation.

Definition at line 136 of file SkCodec.h.

                               {
        /**
         *  If the container format contains both still images and image sequences,
         *  SkCodec should choose one of the still images. This is the default.
         *  Note that kPreferStillImage may prevent use of the animation features
         *  if the input is not rewindable.
         */
        kPreferStillImage,
        /**
         *  If the container format contains both still images and image sequences,
         *  SkCodec should choose one of the image sequences for animation.
         */
        kPreferAnimation,
    };

◆ SkScanlineOrder

enum SkCodec::SkScanlineOrder

The order in which rows are output from the scanline decoder is not the same for all variations of all image types. This explains the possible output row orderings.

Enumerator
kTopDown_SkScanlineOrder
kBottomUp_SkScanlineOrder

Definition at line 575 of file SkCodec.h.

                         {
        /*
         * By far the most common, this indicates that the image can be decoded
         * reliably using the scanline decoder, and that rows will be output in
         * the logical order.
         */
        kTopDown_SkScanlineOrder,
 
        /*
         * This indicates that the scanline decoder reliably outputs rows, but
         * they will be returned in reverse order.  If the scanline format is
         * kBottomUp, the nextScanline() API can be used to determine the actual
         * y-coordinate of the next output row, but the client is not forced
         * to take advantage of this, given that it's not too tough to keep
         * track independently.
         *
         * For full image decodes, it is safe to get all of the scanlines at
         * once, since the decoder will handle inverting the rows as it
         * decodes.
         *
         * For subset decodes and sampling, it is simplest to get and skip
         * scanlines one at a time, using the nextScanline() API.  It is
         * possible to ask for larger chunks at a time, but this should be used
         * with caution.  As with full image decodes, the decoder will handle
         * inverting the requested rows, but rows will still be delivered
         * starting from the bottom of the image.
         *
         * Upside down bmps are an example.
         */
        kBottomUp_SkScanlineOrder,
    };

◆ ZeroInitialized

enum SkCodec::ZeroInitialized

Whether or not the memory passed to getPixels is zero initialized.

Enumerator

kYes_ZeroInitialized

The memory passed to getPixels is zero initialized. The SkCodec may take advantage of this by skipping writing zeroes.

kNo_ZeroInitialized

The memory passed to getPixels has not been initialized to zero, so the SkCodec must write all zeroes to memory.

This is the default. It will be used if no Options struct is used.

Definition at line 303 of file SkCodec.h.

                         {
        /**
         *  The memory passed to getPixels is zero initialized. The SkCodec
         *  may take advantage of this by skipping writing zeroes.
         */
        kYes_ZeroInitialized,
        /**
         *  The memory passed to getPixels has not been initialized to zero,
         *  so the SkCodec must write all zeroes to memory.
         *
         *  This is the default. It will be used if no Options struct is used.
         */
        kNo_ZeroInitialized,
    };

Constructor & Destructor Documentation

◆ ~SkCodec()

SkCodec::~SkCodec ( )

virtual

Definition at line 261 of file SkCodec.cpp.

261{}

◆ SkCodec()

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

protected

Definition at line 250 of file SkCodec.cpp.

        : fEncodedInfo(std::move(info))
        , fSrcXformFormat(srcFormat)
        , fStream(std::move(stream))
        , fOrigin(origin)
        , fDstInfo()
        , fOptions() {}

Member Function Documentation

◆ applyColorXform()

void SkCodec::applyColorXform	(	void *	dst,
		const void *	src,
		int	count
	)		const

protected

Definition at line 853 of file SkCodec.cpp.

                                                                         {
    // It is okay for srcProfile to be null. This will use sRGB.
    const auto* srcProfile = fEncodedInfo.profile();
    SkAssertResult(skcms_Transform(src, fSrcXformFormat, skcms_AlphaFormat_Unpremul, srcProfile,
                                   dst, fDstXformFormat, fDstXformAlphaFormat, &fDstProfile,
                                   count));
}

◆ bounds()

SkIRect SkCodec::bounds ( ) const

inline

Definition at line 231 of file SkCodec.h.

                           {
        return SkIRect::MakeWH(fEncodedInfo.width(), fEncodedInfo.height());
    }

◆ colorXform()

bool SkCodec::colorXform ( ) const

inlineprotected

Definition at line 906 of file SkCodec.h.

906{ return fXformTime != kNo_XformTime; }

◆ conversionSupported()

bool SkCodec::conversionSupported	(	const SkImageInfo &	dst,
		bool	srcIsOpaque,
		bool	needsColorXform
	)

protectedvirtual

Return whether we can convert to dst.

Will be called for the appropriate frame, prior to initializing the colorXform.

Reimplemented in SkHeifCodec, SkIcoCodec, SkJpegCodec, SkJpegxlCodec, and SkWbmpCodec.

Definition at line 286 of file SkCodec.cpp.

                                                                                                {
    if (!valid_alpha(dst.alphaType(), srcIsOpaque)) {
        return false;
    }
 
    switch (dst.colorType()) {
        case kRGBA_8888_SkColorType:
        case kBGRA_8888_SkColorType:
        case kRGBA_F16_SkColorType:
        case kBGRA_10101010_XR_SkColorType:
            return true;
        case kBGR_101010x_XR_SkColorType:
        case kRGB_565_SkColorType:
            return srcIsOpaque;
        case kGray_8_SkColorType:
            return SkEncodedInfo::kGray_Color == fEncodedInfo.color() && srcIsOpaque;
        case kAlpha_8_SkColorType:
            // conceptually we can convert anything into alpha_8, but we haven't actually coded
            // all of those other conversions yet.
            return SkEncodedInfo::kXAlpha_Color == fEncodedInfo.color();
        default:
            return false;
    }
}

◆ currScanline()

int SkCodec::currScanline ( ) const

inlineprotected

Returns the number of scanlines that have been decoded so far. This is unaffected by the SkScanlineOrder.

Returns -1 if we have not started a scanline decode.

Definition at line 888 of file SkCodec.h.

888{ return fCurrScanline; }

◆ dimensions()

SkISize SkCodec::dimensions ( ) const

inline

Definition at line 230 of file SkCodec.h.

230{ return {fEncodedInfo.width(), fEncodedInfo.height()}; }

◆ dstInfo()

const SkImageInfo & SkCodec::dstInfo ( ) const

inlineprotected

Definition at line 878 of file SkCodec.h.

878{ return fDstInfo; }

◆ getEncodedData()

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

virtual

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

Reimplemented in SkWuffsCodec.

Definition at line 1046 of file SkCodec.cpp.

                                                      {
    SkASSERT(fStream);
    if (!fStream) {
        return nullptr;
    }
    return fStream->duplicate();
}

◆ getEncodedFormat()

SkEncodedImageFormat SkCodec::getEncodedFormat ( ) const

inline

Format of the encoded data.

Definition at line 292 of file SkCodec.h.

292{ return this->onGetEncodedFormat(); }

SkCodec::onGetEncodedFormat

virtual SkEncodedImageFormat onGetEncodedFormat() const =0

◆ getEncodedInfo()

const SkEncodedInfo & SkCodec::getEncodedInfo ( ) const

inlineprotected

Definition at line 788 of file SkCodec.h.

788{ return fEncodedInfo; }

◆ getFrameCount()

int SkCodec::getFrameCount ( )

inline

Return the number of frames in the image.

May require reading through the stream.

Definition at line 641 of file SkCodec.h.

                        {
        return this->onGetFrameCount();
    }

◆ getFrameHolder()

virtual const SkFrameHolder * SkCodec::getFrameHolder ( ) const

inlineprivatevirtual

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

Reimplemented in SkAvifCodec, SkHeifCodec, and SkWebpCodec.

Definition at line 968 of file SkCodec.h.

                                                        {
        return nullptr;
    }

◆ getFrameInfo() [1/2]

std::vector< SkCodec::FrameInfo > SkCodec::getFrameInfo ( )

Return info about all the frames in the image.

May require reading through the stream to determine info about the frames (including the count).

As such, future decoding calls may require a rewind.

This may return an empty vector for non-animated codecs. See the getFrameInfo(int, FrameInfo*) comment.

Definition at line 861 of file SkCodec.cpp.

                                                  {
    const int frameCount = this->getFrameCount();
    SkASSERT(frameCount >= 0);
    if (frameCount <= 0) {
        return std::vector<FrameInfo>{};
    }
 
    if (frameCount == 1 && !this->onGetFrameInfo(0, nullptr)) {
        // Not animated.
        return std::vector<FrameInfo>{};
    }
 
    std::vector<FrameInfo> result(frameCount);
    for (int i = 0; i < frameCount; ++i) {
        SkAssertResult(this->onGetFrameInfo(i, &result[i]));
    }
    return result;
}

◆ getFrameInfo() [2/2]

bool SkCodec::getFrameInfo	(	int	index,
		FrameInfo *	info
	)		const

inline

Return info about a single frame.

Does not read through the stream, so it should be called after getFrameCount() to parse any frames that have not already been parsed.

Only supported by animated (multi-frame) codecs. Note that this is a property of the codec (the SkCodec subclass), not the image.

To elaborate, some codecs support animation (e.g. GIF). Others do not (e.g. BMP). Animated codecs can still represent single frame images. Calling getFrameInfo(0, etc) will return true for a single frame GIF even if the overall image is not animated (in that the pixels on screen do not change over time). When incrementally decoding a GIF image, we might only know that there's a single frame so far.

For non-animated SkCodec subclasses, it's sufficient but not necessary for this method to always return false.

Definition at line 739 of file SkCodec.h.

                                                        {
        if (index < 0) {
            return false;
        }
        return this->onGetFrameInfo(index, info);
    }

◆ getICCProfile()

const skcms_ICCProfile * SkCodec::getICCProfile ( ) const

inline

Return the ICC profile of the encoded data.

Definition at line 238 of file SkCodec.h.

                                                  {
        return this->getEncodedInfo().profile();
    }

◆ getImage() [1/2]

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

Definition at line 565 of file SkCodec.cpp.

                                                          {
    // If the codec reports that it is rotated, we need to rotate the image info
    // it says it is, so the output is what the user wants.
    SkImageInfo info = this->getInfo();
    if (SkEncodedOriginSwapsWidthHeight(this->getOrigin())) {
        info = SkPixmapUtils::SwapWidthHeight(info);
    }
    return this->getImage(info, nullptr);
}

◆ getImage() [2/2]

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

Return an image containing the pixels. If the codec's origin is not "upper left", This will rotate the output image accordingly.

Definition at line 533 of file SkCodec.cpp.

                                                                                      {
    SkBitmap bm;
    if (!bm.tryAllocPixels(info)) {
        return {nullptr, kInternalError};
    }
 
    Result result;
    auto decode = [this, options, &result](const SkPixmap& pm) {
        result = this->getPixels(pm, options);
        switch (result) {
            case SkCodec::kSuccess:
            case SkCodec::kIncompleteInput:
            case SkCodec::kErrorInInput:
                return true;
            default:
                return false;
        }
    };
 
    // If the codec reports this image is rotated, we will decode it into
    // a temporary buffer, then copy it (rotated) into the pixmap belonging
    // to bm that we allocated above. If the image is not rotated, we will
    // decode straight into that allocated pixmap.
    if (!SkPixmapUtils::Orient(bm.pixmap(), this->getOrigin(), decode)) {
        return {nullptr, result};
    }
    // Setting the bitmap to be immutable saves us from having to copy it.
    bm.setImmutable();
    return {SkImages::RasterFromBitmap(bm), kSuccess};
}

◆ getInfo()

SkImageInfo SkCodec::getInfo ( ) const

inline

Return a reasonable SkImageInfo to decode into.

If the image has an ICC profile that does not map to an SkColorSpace, the returned SkImageInfo will use SRGB.

Definition at line 228 of file SkCodec.h.

228{ return fEncodedInfo.makeImageInfo(); }

SkEncodedInfo::makeImageInfo

SkImageInfo makeImageInfo() const

Definition: SkEncodedInfo.h:183

◆ getOrigin()

SkEncodedOrigin SkCodec::getOrigin ( ) const

inline

Returns the image orientation stored in the EXIF data. If there is no EXIF data, or if we cannot read the EXIF data, returns kTopLeft.

Definition at line 246 of file SkCodec.h.

246{ return fOrigin; }

◆ getPixels() [1/3]

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

inline

Simplified version of getPixels() that uses the default Options.

Definition at line 412 of file SkCodec.h.

                                                                             {
        return this->getPixels(info, pixels, rowBytes, nullptr);
    }

◆ getPixels() [2/3]

SkCodec::Result SkCodec::getPixels	(	const SkImageInfo &	info,
		void *	pixels,
		size_t	rowBytes,
		const Options *	options
	)

Decode into the given pixels, a block of memory of size at least (info.fHeight - 1) * rowBytes + (info.fWidth * bytesPerPixel)

Repeated calls to this function should give the same results, allowing the PixelRef to be immutable.

Parameters

info	A description of the format (config, size) expected by the caller. This can simply be identical to the info returned by getInfo().

This contract also allows the caller to specify different output-configs, which the implementation can decide to support or not.

A size that does not match getInfo() implies a request to scale. If the generator cannot perform this scale, it will return kInvalidScale.

If the info contains a non-null SkColorSpace, the codec will perform the appropriate color space transformation.

If the caller passes in the SkColorSpace that maps to the ICC profile reported by getICCProfile(), the color space transformation is a no-op.

If the caller passes a null SkColorSpace, no color space transformation will be done.

If a scanline decode is in progress, scanline mode will end, requiring the client to call startScanlineDecode() in order to return to decoding scanlines.

Returns: Result kSuccess, or another value explaining the type of failure.

Definition at line 467 of file SkCodec.cpp.

                                                           {
    if (kUnknown_SkColorType == info.colorType()) {
        return kInvalidConversion;
    }
    if (nullptr == pixels) {
        return kInvalidParameters;
    }
    if (rowBytes < info.minRowBytes()) {
        return kInvalidParameters;
    }
 
    // Default options.
    Options optsStorage;
    if (nullptr == options) {
        options = &optsStorage;
    } else {
        if (options->fSubset) {
            SkIRect subset(*options->fSubset);
            if (!this->onGetValidSubset(&subset) || subset != *options->fSubset) {
                // FIXME: How to differentiate between not supporting subset at all
                // and not supporting this particular subset?
                return kUnimplemented;
            }
        }
    }
 
    const Result frameIndexResult = this->handleFrameIndex(info, pixels, rowBytes,
                                                           *options);
    if (frameIndexResult != kSuccess) {
        return frameIndexResult;
    }
 
    // FIXME: Support subsets somehow? Note that this works for SkWebpCodec
    // because it supports arbitrary scaling/subset combinations.
    if (!this->dimensionsSupported(info.dimensions())) {
        return kInvalidScale;
    }
 
    fDstInfo = info;
    fOptions = *options;
 
    // On an incomplete decode, the subclass will specify the number of scanlines that it decoded
    // successfully.
    int rowsDecoded = 0;
    const Result result = this->onGetPixels(info, pixels, rowBytes, *options, &rowsDecoded);
 
    // A return value of kIncompleteInput indicates a truncated image stream.
    // In this case, we will fill any uninitialized memory with a default value.
    // Some subclasses will take care of filling any uninitialized memory on
    // their own.  They indicate that all of the memory has been filled by
    // setting rowsDecoded equal to the height.
    if ((kIncompleteInput == result || kErrorInInput == result) && rowsDecoded != info.height()) {
        // FIXME: (skbug.com/5772) fillIncompleteImage will fill using the swizzler's width, unless
        // there is a subset. In that case, it will use the width of the subset. From here, the
        // subset will only be non-null in the case of SkWebpCodec, but it treats the subset
        // differenty from the other codecs, and it needs to use the width specified by the info.
        // Set the subset to null so SkWebpCodec uses the correct width.
        fOptions.fSubset = nullptr;
        this->fillIncompleteImage(info, pixels, rowBytes, options->fZeroInitialized, info.height(),
                rowsDecoded);
    }
 
    return result;
}

◆ getPixels() [3/3]

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

inline

Definition at line 416 of file SkCodec.h.

                                                                        {
        return this->getPixels(pm.info(), pm.writable_addr(), pm.rowBytes(), opts);
    }

◆ getRepetitionCount()

int SkCodec::getRepetitionCount ( )

inline

Return the number of times to repeat, if this image is animated. This number does not include the first play through of each frame. For example, a repetition count of 4 means that each frame is played 5 times and then the animation stops.

It can return kRepetitionCountInfinite, a negative number, meaning that the animation should loop forever.

May require reading the stream to find the repetition count.

As such, future decoding calls may require a rewind.

For still (non-animated) image codecs, this will return 0.

Definition at line 775 of file SkCodec.h.

                             {
        return this->onGetRepetitionCount();
    }

◆ getSampler()

virtual SkSampler * SkCodec::getSampler ( bool )

inlineprivatevirtual

Return an object which will allow forcing scanline decodes to sample in X.

May create a sampler, if one is not currently being used. Otherwise, does not affect ownership.

Only valid during scanline decoding or incremental decoding.

Reimplemented in SkBmpStandardCodec, and SkPngCodec.

Definition at line 1035 of file SkCodec.h.

1035{ return nullptr; }

◆ getScaledDimensions()

SkISize SkCodec::getScaledDimensions ( float desiredScale ) const

inline

Return a size that approximately supports the desired scale factor. The codec may not be able to scale efficiently to the exact scale factor requested, so return a size that approximates that scale. The returned value is the codec's suggestion for the closest valid scale that it can natively support

Definition at line 255 of file SkCodec.h.

                                                          {
        // Negative and zero scales are errors.
        SkASSERT(desiredScale > 0.0f);
        if (desiredScale <= 0.0f) {
            return SkISize::Make(0, 0);
        }
 
        // Upscaling is not supported. Return the original size if the client
        // requests an upscale.
        if (desiredScale >= 1.0f) {
            return this->dimensions();
        }
        return this->onGetScaledDimensions(desiredScale);
    }

◆ getScanlineOrder()

SkScanlineOrder SkCodec::getScanlineOrder ( ) const

inline

An enum representing the order in which scanlines will be returned by the scanline decoder.

This is undefined before startScanlineDecode() is called.

Definition at line 613 of file SkCodec.h.

613{ return this->onGetScanlineOrder(); }

SkCodec::onGetScanlineOrder

virtual SkScanlineOrder onGetScanlineOrder() const

Definition: SkCodec.h:876

◆ getScanlines()

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

Write the next countLines scanlines into dst.

Not valid to call before calling startScanlineDecode().

Parameters

dst	Must be non-null, and large enough to hold countLines scanlines of size rowBytes.
countLines	Number of lines to write.
rowBytes	Number of bytes per row. Must be large enough to hold a scanline based on the SkImageInfo used to create this object.

Returns: the number of lines successfully decoded. If this value is less than countLines, this will fill the remaining lines with a default value.

Definition at line 694 of file SkCodec.cpp.

                                                                    {
    if (fCurrScanline < 0) {
        return 0;
    }
 
    SkASSERT(!fDstInfo.isEmpty());
    if (countLines <= 0 || fCurrScanline + countLines > fDstInfo.height()) {
        return 0;
    }
 
    const int linesDecoded = this->onGetScanlines(dst, countLines, rowBytes);
    if (linesDecoded < countLines) {
        this->fillIncompleteImage(this->dstInfo(), dst, rowBytes, this->options().fZeroInitialized,
                countLines, linesDecoded);
    }
    fCurrScanline += countLines;
    return linesDecoded;
}

◆ getSrcXformFormat()

XformFormat SkCodec::getSrcXformFormat ( ) const

inlineprotected

Definition at line 799 of file SkCodec.h.

                                          {
        return fSrcXformFormat;
    }

◆ getValidSubset()

bool SkCodec::getValidSubset ( SkIRect * desiredSubset ) const

inline

Return (via desiredSubset) a subset which can decoded from this codec, or false if this codec cannot decode subsets or anything similar to desiredSubset.

Parameters

desiredSubset In/out parameter. As input, a desired subset of the original bounds (as specified by getInfo). If true is returned, desiredSubset may have been modified to a subset which is supported. Although a particular change may have been made to desiredSubset to create something supported, it is possible other changes could result in a valid subset. If false is returned, desiredSubset's value is undefined.

Returns: true if this codec supports decoding desiredSubset (as returned, potentially modified)

Definition at line 285 of file SkCodec.h.

                                                      {
        return this->onGetValidSubset(desiredSubset);
    }

◆ getYUVAPlanes()

SkCodec::Result SkCodec::getYUVAPlanes ( const SkYUVAPixmaps & yuvaPixmaps )

Returns kSuccess, or another value explaining the type of failure. This always attempts to perform a full decode. To get the planar configuration without decoding use queryYUVAInfo().

Parameters

yuvaPixmaps Contains preallocated pixmaps configured according to a successful call to queryYUVAInfo().

Definition at line 276 of file SkCodec.cpp.

                                                                     {
    if (!yuvaPixmaps.isValid()) {
        return kInvalidInput;
    }
    if (!this->rewindIfNeeded()) {
        return kCouldNotRewind;
    }
    return this->onGetYUVAPlanes(yuvaPixmaps);
}

◆ incrementalDecode()

Result SkCodec::incrementalDecode ( int * rowsDecoded = nullptr )

inline

Start/continue the incremental decode.

Not valid to call before a call to startIncrementalDecode() returns kSuccess.

If kIncompleteInput is returned, may be called again after more data has been provided to the source SkStream.

Unlike getPixels and getScanlines, this does not do any filling. This is left up to the caller, since they may be skipping lines or continuing the decode later. In the latter case, they may choose to initialize all lines first, or only initialize the remaining lines after the first call.

Parameters

rowsDecoded Optional output variable returning the total number of lines initialized. Only meaningful if this method returns kIncompleteInput. Otherwise the implementation may not set it. Note that some implementations may have initialized this many rows, but not necessarily finished those rows (e.g. interlaced PNG). This may be useful for determining what rows the client needs to initialize.

Returns: kSuccess if all lines requested in startIncrementalDecode have been completely decoded. kIncompleteInput otherwise.

Definition at line 498 of file SkCodec.h.

                                                         {
        if (!fStartedIncrementalDecode) {
            return kInvalidParameters;
        }
        return this->onIncrementalDecode(rowsDecoded);
    }

◆ MakeFromData() [1/2]

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

static

Definition at line 238 of file SkCodec.cpp.

                                                                                         {
    return MakeFromData(std::move(data), SkCodecs::get_decoders(), reader);
}

◆ MakeFromData() [2/2]

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

static

If this data represents an encoded image that we know how to decode, return an SkCodec that can decode it. Otherwise return NULL.

If the SkPngChunkReader is not NULL then: If the image is not a PNG, the SkPngChunkReader will be ignored. If the image is a PNG, the SkPngChunkReader will be reffed. If the PNG has unknown chunks, the SkPngChunkReader will be used to handle these chunks. SkPngChunkReader will be called to read any unknown chunk at any point during the creation of the codec or the decode. Note that if SkPngChunkReader fails to read a chunk, this could result in a failure to create the codec or a failure to decode the image. If the PNG does not contain unknown chunks, the SkPngChunkReader will not be used or modified.

Definition at line 241 of file SkCodec.cpp.

                                                                         {
    if (!data) {
        return nullptr;
    }
    return MakeFromStream(SkMemoryStream::Make(std::move(data)), decoders, nullptr, reader);
}

◆ MakeFromStream() [1/2]

std::unique_ptr< SkCodec > SkCodec::MakeFromStream	(	std::unique_ptr< SkStream >	stream,
		Result *	outResult = `nullptr`,
		SkPngChunkReader *	chunkReader = `nullptr`,
		SelectionPolicy	selectionPolicy = `SelectionPolicy::kPreferStillImage`
	)

static

Definition at line 157 of file SkCodec.cpp.

                                                                        {
    return MakeFromStream(std::move(stream), SkCodecs::get_decoders(), outResult,
                          chunkReader, selectionPolicy);
}

◆ MakeFromStream() [2/2]

std::unique_ptr< SkCodec > SkCodec::MakeFromStream	(	std::unique_ptr< SkStream >	stream,
		SkSpan< const SkCodecs::Decoder >	decoders,
		Result *	outResult = `nullptr`,
		SkPngChunkReader *	chunkReader = `nullptr`,
		SelectionPolicy	selectionPolicy = `SelectionPolicy::kPreferStillImage`
	)

static

If this stream represents an encoded image that we know how to decode, return an SkCodec that can decode it. Otherwise return NULL.

As stated above, this call must be able to peek or read MinBufferedBytesNeeded to determine the correct format, and then start reading from the beginning. First it will attempt to peek, and it assumes that if less than MinBufferedBytesNeeded bytes (but more than zero) are returned, this is because the stream is shorter than this, so falling back to reading would not provide more data. If peek() returns zero bytes, this call will instead attempt to read(). This will require that the stream can be rewind()ed.

If Result is not NULL, it will be set to either kSuccess if an SkCodec is returned or a reason for the failure if NULL is returned.

If SkPngChunkReader is not NULL, take a ref and pass it to libpng if the image is a png.

If the SkPngChunkReader is not NULL then: If the image is not a PNG, the SkPngChunkReader will be ignored. If the image is a PNG, the SkPngChunkReader will be reffed. If the PNG has unknown chunks, the SkPngChunkReader will be used to handle these chunks. SkPngChunkReader will be called to read any unknown chunk at any point during the creation of the codec or the decode. Note that if SkPngChunkReader fails to read a chunk, this could result in a failure to create the codec or a failure to decode the image. If the PNG does not contain unknown chunks, the SkPngChunkReader will not be used or modified.

If NULL is returned, the stream is deleted immediately. Otherwise, the SkCodec takes ownership of it, and will delete it when done with it.

Definition at line 163 of file SkCodec.cpp.

                                                                                           {
    Result resultStorage;
    if (!outResult) {
        outResult = &resultStorage;
    }
 
    if (!stream) {
        *outResult = kInvalidInput;
        return nullptr;
    }
 
    if (selectionPolicy != SelectionPolicy::kPreferStillImage
            && selectionPolicy != SelectionPolicy::kPreferAnimation) {
        *outResult = kInvalidParameters;
        return nullptr;
    }
 
    constexpr size_t bytesToRead = MinBufferedBytesNeeded();
 
    char buffer[bytesToRead];
    size_t bytesRead = stream->peek(buffer, bytesToRead);
 
    // It is also possible to have a complete image less than bytesToRead bytes
    // (e.g. a 1 x 1 wbmp), meaning peek() would return less than bytesToRead.
    // Assume that if bytesRead < bytesToRead, but > 0, the stream is shorter
    // than bytesToRead, so pass that directly to the decoder.
    // It also is possible the stream uses too small a buffer for peeking, but
    // we trust the caller to use a large enough buffer.
 
    if (0 == bytesRead) {
        // TODO: After implementing peek in CreateJavaOutputStreamAdaptor.cpp, this
        // printf could be useful to notice failures.
        // SkCodecPrintf("Encoded image data failed to peek!\n");
 
        // It is possible the stream does not support peeking, but does support
        // rewinding.
        // Attempt to read() and pass the actual amount read to the decoder.
        bytesRead = stream->read(buffer, bytesToRead);
        if (!stream->rewind()) {
            SkCodecPrintf("Encoded image data could not peek or rewind to determine format!\n");
            *outResult = kCouldNotRewind;
            return nullptr;
        }
    }
 
    SkCodecs::MakeFromStreamCallback rawFallback = nullptr;
    for (const SkCodecs::Decoder& proc : decoders) {
        if (proc.isFormat(buffer, bytesRead)) {
            // Some formats are special, since we want to be able to provide an extra parameter.
            if (proc.id == "png") {
                return proc.makeFromStream(std::move(stream), outResult, chunkReader);
            } else if (proc.id == "heif" || proc.id == "gif") {
                return proc.makeFromStream(std::move(stream), outResult, &selectionPolicy);
            } else if (proc.id == "raw") {
                rawFallback = proc.makeFromStream;
                continue;
            }
            return proc.makeFromStream(std::move(stream), outResult, nullptr);
        }
    }
    if (rawFallback != nullptr) {
        // Fallback to raw.
        return rawFallback(std::move(stream), outResult, nullptr);
    }
 
    if (bytesRead < bytesToRead) {
        *outResult = kIncompleteInput;
    } else {
        *outResult = kUnimplemented;
    }
    return nullptr;
}

◆ MinBufferedBytesNeeded()

static constexpr size_t SkCodec::MinBufferedBytesNeeded ( )

inlinestaticconstexpr

Minimum number of bytes that must be buffered in SkStream input.

An SkStream passed to NewFromStream must be able to use this many bytes to determine the image type. Then the same SkStream must be passed to the correct decoder to read from the beginning.

This can be accomplished by implementing peek() to support peeking this many bytes, or by implementing rewind() to be able to rewind() after reading this many bytes.

Definition at line 71 of file SkCodec.h.

71{ return 32; }

◆ nextScanline()

int SkCodec::nextScanline ( ) const

inline

Returns the y-coordinate of the next row to be returned by the scanline decoder.

This will equal fCurrScanline, except in the case of strangely encoded image types (bottom-up bmps).

Results are undefined when not in scanline decoding mode.

Definition at line 624 of file SkCodec.h.

624{ return this->outputScanline(fCurrScanline); }

SkCodec::outputScanline

int outputScanline(int inputScanline) const

Definition: SkCodec.cpp:731

◆ onDimensionsSupported()

virtual bool SkCodec::onDimensionsSupported ( const SkISize & )

inlineprotectedvirtual

Subclasses should override if they support dimensions other than the srcInfo's.

Reimplemented in SkIcoCodec, SkJpegCodec, SkRawCodec, and SkScalingCodec.

Definition at line 815 of file SkCodec.h.

                                                       {
        return false;
    }

◆ onGetEncodedFormat()

virtual SkEncodedImageFormat SkCodec::onGetEncodedFormat ( ) const

protectedpure virtual

Implemented in SkAvifCodec, SkBmpCodec, SkHeifCodec, SkIcoCodec, SkJpegCodec, SkJpegxlCodec, SkPngCodec, SkRawCodec, SkWbmpCodec, and SkWebpCodec.

◆ onGetFrameCount()

virtual int SkCodec::onGetFrameCount ( )

inlineprotectedvirtual

Reimplemented in SkAvifCodec, SkHeifCodec, SkJpegxlCodec, and SkWebpCodec.

Definition at line 909 of file SkCodec.h.

                                  {
        return 1;
    }

◆ onGetFrameInfo()

virtual bool SkCodec::onGetFrameInfo	(	int	,
		FrameInfo *
	)		const

inlineprotectedvirtual

Reimplemented in SkAvifCodec, SkHeifCodec, SkJpegxlCodec, and SkWebpCodec.

Definition at line 913 of file SkCodec.h.

                                                       {
        return false;
    }

◆ onGetGainmapInfo()

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

inlineprotectedvirtual

Reimplemented in SkJpegCodec.

Definition at line 803 of file SkCodec.h.

803{ return false; }

◆ onGetPixels()

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

protectedpure virtual

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.

Implemented in SkPngCodec, SkWbmpCodec, SkWebpCodec, SkBmpMaskCodec, SkBmpRLECodec, SkBmpStandardCodec, SkIcoCodec, SkJpegCodec, SkRawCodec, SkAvifCodec, SkHeifCodec, and SkJpegxlCodec.

◆ onGetRepetitionCount()

virtual int SkCodec::onGetRepetitionCount ( )

inlineprotectedvirtual

Reimplemented in SkAvifCodec, SkHeifCodec, SkJpegxlCodec, and SkWebpCodec.

Definition at line 917 of file SkCodec.h.

                                       {
        return 0;
    }

◆ onGetScaledDimensions()

virtual SkISize SkCodec::onGetScaledDimensions ( float ) const

inlineprotectedvirtual

Reimplemented in SkIcoCodec, SkJpegCodec, SkRawCodec, and SkScalingCodec.

Definition at line 805 of file SkCodec.h.

                                                         {
        // By default, scaling is not supported.
        return this->dimensions();
    }

◆ onGetScanlineOrder()

virtual SkScanlineOrder SkCodec::onGetScanlineOrder ( ) const

inlineprotectedvirtual

The remaining functions revolve around decoding scanlines. Most images types will be kTopDown and will not need to override this function.

Reimplemented in SkBmpCodec, and SkIcoCodec.

Definition at line 876 of file SkCodec.h.

876{ return kTopDown_SkScanlineOrder; }

◆ onGetScanlines()

virtual int SkCodec::onGetScanlines	(	void *	,
		int	,
		size_t
	)

inlineprivatevirtual

Definition at line 1008 of file SkCodec.h.

1008{ return 0; }

◆ onGetValidSubset()

virtual bool SkCodec::onGetValidSubset ( SkIRect * ) const

inlineprotectedvirtual

Reimplemented in SkWebpCodec.

Definition at line 836 of file SkCodec.h.

                                                    {
        // By default, subsets are not supported.
        return false;
    }

◆ onGetYUVAPlanes()

virtual Result SkCodec::onGetYUVAPlanes ( const SkYUVAPixmaps & )

inlineprotectedvirtual

Reimplemented in SkJpegCodec.

Definition at line 834 of file SkCodec.h.

834{ return kUnimplemented; }

◆ onIncrementalDecode()

virtual Result SkCodec::onIncrementalDecode ( int * )

inlineprivatevirtual

Reimplemented in SkPngCodec.

Definition at line 1001 of file SkCodec.h.

                                             {
        return kUnimplemented;
    }

◆ onOutputScanline()

int SkCodec::onOutputScanline ( int inputScanline ) const

protectedvirtual

Definition at line 736 of file SkCodec.cpp.

                                                     {
    switch (this->getScanlineOrder()) {
        case kTopDown_SkScanlineOrder:
            return inputScanline;
        case kBottomUp_SkScanlineOrder:
            return fEncodedInfo.height() - inputScanline - 1;
        default:
            // This case indicates an interlaced gif and is implemented by SkGifCodec.
            SkASSERT(false);
            return 0;
    }
}

◆ onQueryYUVAInfo()

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

inlineprotectedvirtual

Reimplemented in SkJpegCodec.

Definition at line 831 of file SkCodec.h.

832 { return false; }

◆ onRewind()

virtual bool SkCodec::onRewind ( )

inlineprotectedvirtual

Called by rewindIfNeeded, if the stream needed to be rewound.

Subclasses should do any set up needed after a rewind.

Reimplemented in SkBmpCodec, SkHeifCodec, SkJpegCodec, SkJpegxlCodec, SkPngCodec, and SkWbmpCodec.

Definition at line 858 of file SkCodec.h.

                            {
        return true;
    }

◆ onSkipScanlines()

virtual bool SkCodec::onSkipScanlines ( int )

inlineprivatevirtual

Definition at line 1006 of file SkCodec.h.

1006{ return false; }

◆ onStartIncrementalDecode()

virtual Result SkCodec::onStartIncrementalDecode	(	const SkImageInfo &	,
		void *	,
		size_t	,
		const Options &
	)

inlineprivatevirtual

Reimplemented in SkPngCodec.

Definition at line 996 of file SkCodec.h.

                            {
        return kUnimplemented;
    }

◆ onStartScanlineDecode()

virtual Result SkCodec::onStartScanlineDecode	(	const SkImageInfo &	,
		const Options &
	)

inlineprivatevirtual

Definition at line 991 of file SkCodec.h.

                              {
        return kUnimplemented;
    }

◆ options()

const Options & SkCodec::options ( ) const

inlineprotected

Definition at line 880 of file SkCodec.h.

880{ return fOptions; }

◆ outputScanline()

int SkCodec::outputScanline ( int inputScanline ) const

Returns the output y-coordinate of the row that corresponds to an input y-coordinate. The input y-coordinate represents where the scanline is located in the encoded data.

This will equal inputScanline, except in the case of strangely encoded image types (bottom-up bmps, interlaced gifs).

Definition at line 731 of file SkCodec.cpp.

                                                   {
    SkASSERT(0 <= inputScanline && inputScanline < fEncodedInfo.height());
    return this->onOutputScanline(inputScanline);
}

◆ queryYUVAInfo()

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

If decoding to YUV is supported, this returns true. Otherwise, this returns false and the caller will ignore output parameter yuvaPixmapInfo.

Parameters

supportedDataTypes	Indicates the data type/planar config combinations that are supported by the caller. If the generator supports decoding to YUV(A), but not as a type in supportedDataTypes, this method returns false.
yuvaPixmapInfo	Output parameter that specifies the planar configuration, subsampling, orientation, chroma siting, plane color types, and row bytes.

Definition at line 267 of file SkCodec.cpp.

                                                                    {
    if (!yuvaPixmapInfo) {
        return false;
    }
    return this->onQueryYUVAInfo(supportedDataTypes, yuvaPixmapInfo) &&
           yuvaPixmapInfo->isSupported(supportedDataTypes);
}

◆ Register()

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

static

◆ ResultToString()

const char * SkCodec::ResultToString ( Result result )

static

Readable string representing the error code.

Definition at line 880 of file SkCodec.cpp.

                                                 {
    switch (result) {
        case kSuccess:
            return "success";
        case kIncompleteInput:
            return "incomplete input";
        case kErrorInInput:
            return "error in input";
        case kInvalidConversion:
            return "invalid conversion";
        case kInvalidScale:
            return "invalid scale";
        case kInvalidParameters:
            return "invalid parameters";
        case kInvalidInput:
            return "invalid input";
        case kCouldNotRewind:
            return "could not rewind";
        case kInternalError:
            return "internal error";
        case kUnimplemented:
            return "unimplemented";
        default:
            SkASSERT(false);
            return "bogus result value";
    }
}

◆ rewindIfNeeded()

bool SkCodec::rewindIfNeeded ( )

protected

If the stream was previously read, attempt to rewind.

If the stream needed to be rewound, call onRewind.

Returns: true if the codec is at the right position and can be used. false if there was a failure to rewind.

This is called by getPixels(), getYUV8Planes(), startIncrementalDecode() and startScanlineDecode(). Subclasses may call if they need to rewind at another time.

Definition at line 311 of file SkCodec.cpp.

                             {
    // Store the value of fNeedsRewind so we can update it. Next read will
    // require a rewind.
    const bool needsRewind = fNeedsRewind;
    fNeedsRewind = true;
    if (!needsRewind) {
        return true;
    }
 
    // startScanlineDecode will need to be called before decoding scanlines.
    fCurrScanline = -1;
    // startIncrementalDecode will need to be called before incrementalDecode.
    fStartedIncrementalDecode = false;
 
    // Some codecs do not have a stream.  They may hold onto their own data or another codec.
    // They must handle rewinding themselves.
    if (fStream && !fStream->rewind()) {
        return false;
    }
 
    return this->onRewind();
}

◆ setSrcXformFormat()

void SkCodec::setSrcXformFormat ( XformFormat pixelFormat )

protected

Definition at line 263 of file SkCodec.cpp.

                                                       {
    fSrcXformFormat = pixelFormat;
}

◆ skipScanlines()

bool SkCodec::skipScanlines ( int countLines )

Skip count scanlines.

Not valid to call before calling startScanlineDecode().

The default version just calls onGetScanlines and discards the dst. NOTE: If skipped lines are the only lines with alpha, this default will make reallyHasAlpha return true, when it could have returned false.

Returns: true if the scanlines were successfully skipped false on failure, possible reasons for failure include: An incomplete input image stream. Calling this function before calling startScanlineDecode(). If countLines is less than zero or so large that it moves the current scanline past the end of the image.

Definition at line 713 of file SkCodec.cpp.

                                          {
    if (fCurrScanline < 0) {
        return false;
    }
 
    SkASSERT(!fDstInfo.isEmpty());
    if (countLines < 0 || fCurrScanline + countLines > fDstInfo.height()) {
        // Arguably, we could just skip the scanlines which are remaining,
        // and return true. We choose to return false so the client
        // can catch their bug.
        return false;
    }
 
    bool result = this->onSkipScanlines(countLines);
    fCurrScanline += countLines;
    return result;
}

◆ startIncrementalDecode() [1/2]

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

inline

Definition at line 471 of file SkCodec.h.

                                                                                          {
        return this->startIncrementalDecode(dstInfo, dst, rowBytes, nullptr);
    }

◆ startIncrementalDecode() [2/2]

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

Prepare for an incremental decode with the specified options.

This may require a rewind.

If kIncompleteInput is returned, may be called again after more data has been provided to the source SkStream.

Parameters

dstInfo	Info of the destination. If the dimensions do not match those of getInfo, this implies a scale.
dst	Memory to write to. Needs to be large enough to hold the subset, if present, or the full image as described in dstInfo.
options	Contains decoding options, including if memory is zero initialized and whether to decode a subset.

Returns: Enum representing success or reason for failure.

Definition at line 575 of file SkCodec.cpp.

                                                        {
    fStartedIncrementalDecode = false;
 
    if (kUnknown_SkColorType == info.colorType()) {
        return kInvalidConversion;
    }
    if (nullptr == pixels) {
        return kInvalidParameters;
    }
 
    // Set options.
    Options optsStorage;
    if (nullptr == options) {
        options = &optsStorage;
    } else {
        if (options->fSubset) {
            SkIRect size = SkIRect::MakeSize(info.dimensions());
            if (!size.contains(*options->fSubset)) {
                return kInvalidParameters;
            }
 
            const int top = options->fSubset->top();
            const int bottom = options->fSubset->bottom();
            if (top < 0 || top >= info.height() || top >= bottom || bottom > info.height()) {
                return kInvalidParameters;
            }
        }
    }
 
    const Result frameIndexResult = this->handleFrameIndex(info, pixels, rowBytes,
                                                           *options);
    if (frameIndexResult != kSuccess) {
        return frameIndexResult;
    }
 
    if (!this->dimensionsSupported(info.dimensions())) {
        return kInvalidScale;
    }
 
    fDstInfo = info;
    fOptions = *options;
 
    const Result result = this->onStartIncrementalDecode(info, pixels, rowBytes, fOptions);
    if (kSuccess == result) {
        fStartedIncrementalDecode = true;
    } else if (kUnimplemented == result) {
        // FIXME: This is temporarily necessary, until we transition SkCodec
        // implementations from scanline decoding to incremental decoding.
        // SkAndroidCodec will first attempt to use incremental decoding, but
        // will fall back to scanline decoding if incremental returns
        // kUnimplemented. rewindIfNeeded(), above, set fNeedsRewind to true
        // (after potentially rewinding), but we do not want the next call to
        // startScanlineDecode() to do a rewind.
        fNeedsRewind = false;
    }
    return result;
}

◆ startScanlineDecode() [1/2]

Result SkCodec::startScanlineDecode ( const SkImageInfo & dstInfo )

inline

Simplified version of startScanlineDecode() that uses the default Options.

Definition at line 531 of file SkCodec.h.

                                                           {
        return this->startScanlineDecode(dstInfo, nullptr);
    }

◆ startScanlineDecode() [2/2]

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

The remaining functions revolve around decoding scanlines. Prepare for a scanline decode with the specified options.

After this call, this class will be ready to decode the first scanline.

This must be called in order to call getScanlines or skipScanlines.

This may require rewinding the stream.

Not all SkCodecs support this.

Parameters

dstInfo	Info of the destination. If the dimensions do not match those of getInfo, this implies a scale.
options	Contains decoding options, including if memory is zero initialized.

Returns: Enum representing success or reason for failure.

Definition at line 635 of file SkCodec.cpp.

                                       {
    // Reset fCurrScanline in case of failure.
    fCurrScanline = -1;
 
    // Set options.
    Options optsStorage;
    if (nullptr == options) {
        options = &optsStorage;
    } else if (options->fSubset) {
        SkIRect size = SkIRect::MakeSize(info.dimensions());
        if (!size.contains(*options->fSubset)) {
            return kInvalidInput;
        }
 
        // We only support subsetting in the x-dimension for scanline decoder.
        // Subsetting in the y-dimension can be accomplished using skipScanlines().
        if (options->fSubset->top() != 0 || options->fSubset->height() != info.height()) {
            return kInvalidInput;
        }
    }
 
    // Scanline decoding only supports decoding the first frame.
    if (options->fFrameIndex != 0) {
        return kUnimplemented;
    }
 
    // The void* dst and rowbytes in handleFrameIndex or only used for decoding prior
    // frames, which is not supported here anyway, so it is safe to pass nullptr/0.
    const Result frameIndexResult = this->handleFrameIndex(info, nullptr, 0, *options);
    if (frameIndexResult != kSuccess) {
        return frameIndexResult;
    }
 
    // FIXME: Support subsets somehow?
    if (!this->dimensionsSupported(info.dimensions())) {
        return kInvalidScale;
    }
 
    const Result result = this->onStartScanlineDecode(info, *options);
    if (result != SkCodec::kSuccess) {
        return result;
    }
 
    // FIXME: See startIncrementalDecode. That method set fNeedsRewind to false
    // so that when onStartScanlineDecode calls rewindIfNeeded it would not
    // rewind. But it also relies on that call to rewindIfNeeded to set
    // fNeedsRewind to true for future decodes. When
    // fUsingCallbackForHandleFrameIndex is true, that call to rewindIfNeeded is
    // skipped, so this method sets it back to true.
    SkASSERT(fUsingCallbackForHandleFrameIndex || fNeedsRewind);
    fNeedsRewind = true;
 
    fCurrScanline = 0;
    fDstInfo = info;
    fOptions = *options;
    return kSuccess;
}

◆ stream()

SkStream * SkCodec::stream ( )

inlineprotected

Get method for the input stream

Definition at line 865 of file SkCodec.h.

                       {
        return fStream.get();
    }

◆ usesColorXform()

virtual bool SkCodec::usesColorXform ( ) const

inlineprotectedvirtual

Reimplemented in SkIcoCodec, SkRawCodec, and SkWbmpCodec.

Definition at line 903 of file SkCodec.h.

903{ return true; }

◆ xformOnDecode()

bool SkCodec::xformOnDecode ( ) const

inlineprotected

Definition at line 907 of file SkCodec.h.

907{ return fXformTime == kDecodeRow_XformTime; }

Friends And Related Function Documentation

◆ DM::CodecSrc

friend class DM::CodecSrc

friend

Definition at line 1037 of file SkCodec.h.

◆ PNGCodecGM

friend class PNGCodecGM

friend

Definition at line 1038 of file SkCodec.h.

◆ SkAndroidCodec

friend class SkAndroidCodec

friend

Definition at line 1041 of file SkCodec.h.

◆ SkIcoCodec

friend class SkIcoCodec

friend

Definition at line 1040 of file SkCodec.h.

◆ SkPDFBitmap

friend class SkPDFBitmap

friend

Definition at line 1042 of file SkCodec.h.

◆ SkSampledCodec

friend class SkSampledCodec

friend

Definition at line 1039 of file SkCodec.h.

Member Data Documentation

◆ kNoFrame

constexpr int SkCodec::kNoFrame = -1

staticconstexpr

Definition at line 650 of file SkCodec.h.

◆ kRepetitionCountInfinite

constexpr int SkCodec::kRepetitionCountInfinite = -1

staticconstexpr

Definition at line 759 of file SkCodec.h.

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

third_party/skia/include/codec/SkCodec.h
third_party/skia/src/codec/SkCodec.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ XformFormat

Member Enumeration Documentation

◆ Result

◆ SelectionPolicy

◆ SkScanlineOrder

◆ ZeroInitialized

Constructor & Destructor Documentation

◆ ~SkCodec()

◆ SkCodec()

Member Function Documentation

◆ applyColorXform()

◆ bounds()

◆ colorXform()

◆ conversionSupported()

◆ currScanline()

◆ dimensions()

◆ dstInfo()

◆ getEncodedData()

◆ getEncodedFormat()

◆ getEncodedInfo()

◆ getFrameCount()

◆ getFrameHolder()

◆ getFrameInfo() [1/2]

◆ getFrameInfo() [2/2]

◆ getICCProfile()

◆ getImage() [1/2]

◆ getImage() [2/2]

◆ getInfo()

◆ getOrigin()

◆ getPixels() [1/3]

◆ getPixels() [2/3]

◆ getPixels() [3/3]

◆ getRepetitionCount()

◆ getSampler()

◆ getScaledDimensions()

◆ getScanlineOrder()

◆ getScanlines()

◆ getSrcXformFormat()

◆ getValidSubset()

◆ getYUVAPlanes()

◆ incrementalDecode()

◆ MakeFromData() [1/2]

◆ MakeFromData() [2/2]

◆ MakeFromStream() [1/2]

◆ MakeFromStream() [2/2]

◆ MinBufferedBytesNeeded()

◆ nextScanline()

◆ onDimensionsSupported()

◆ onGetEncodedFormat()

◆ onGetFrameCount()

◆ onGetFrameInfo()

◆ onGetGainmapInfo()

◆ onGetPixels()

◆ onGetRepetitionCount()

◆ onGetScaledDimensions()

◆ onGetScanlineOrder()

◆ onGetScanlines()

◆ onGetValidSubset()

◆ onGetYUVAPlanes()

◆ onIncrementalDecode()

◆ onOutputScanline()

◆ onQueryYUVAInfo()

◆ onRewind()

◆ onSkipScanlines()

◆ onStartIncrementalDecode()

◆ onStartScanlineDecode()

◆ options()

◆ outputScanline()

◆ queryYUVAInfo()