#include <SkAvifCodec.h>

Inheritance diagram for SkAvifCodec:

Static Public Member Functions
static bool	IsAvif (const void *, size_t)

static std::unique_ptr< SkCodec >	MakeFromStream (std::unique_ptr< SkStream >, Result *)

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

Protected Member Functions
Result	onGetPixels (const SkImageInfo &dstInfo, void dst, size_t dstRowBytes, const Options &options, int rowsDecoded) override

SkEncodedImageFormat	onGetEncodedFormat () const override

int	onGetFrameCount () override

bool	onGetFrameInfo (int, FrameInfo *) const override

int	onGetRepetitionCount () override

const SkFrameHolder *	getFrameHolder () const override

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

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 }

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 Attributes inherited from SkCodec
static constexpr int	kNoFrame = -1

static constexpr int	kRepetitionCountInfinite = -1

Protected Types inherited from SkCodec
using	XformFormat = skcms_PixelFormat

Detailed Description

Definition at line 32 of file SkAvifCodec.h.

Member Function Documentation

◆ getFrameHolder()

const SkFrameHolder * SkAvifCodec::getFrameHolder ( ) const

inlineoverrideprotectedvirtual

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

Reimplemented from SkCodec.

Definition at line 56 of file SkAvifCodec.h.

56{ return &fFrameHolder; }

◆ IsAvif()

bool SkAvifCodec::IsAvif	(	const void *	buffer,
		size_t	bytesRead
	)

static

Definition at line 33 of file SkAvifCodec.cpp.

                                                             {
    avifROData avifData = {static_cast<const uint8_t*>(buffer), bytesRead};
    bool isAvif = avifPeekCompatibleFileType(&avifData) == AVIF_TRUE;
    if (isAvif) return true;
    // Peeking sometimes fails if the ftyp box is too large. Check the signature
    // just to be sure.
    const char* bytes = static_cast<const char*>(buffer);
    isAvif = bytesRead >= 12 && !memcmp(&bytes[4], "ftyp", 4) &&
             (!memcmp(&bytes[8], "avif", 4) || !memcmp(&bytes[8], "avis", 4));
    return isAvif;
}

◆ MakeFromStream()

std::unique_ptr< SkCodec > SkAvifCodec::MakeFromStream	(	std::unique_ptr< SkStream >	stream,
		Result *	result
	)

static

Definition at line 45 of file SkAvifCodec.cpp.

                                                                     {
    SkASSERT(result);
    if (!stream) {
        *result = SkCodec::kInvalidInput;
        return nullptr;
    }
    AvifDecoder avifDecoder(avifDecoderCreate());
    if (avifDecoder == nullptr) {
        *result = SkCodec::kInternalError;
        return nullptr;
    }
    avifDecoder->ignoreXMP = AVIF_TRUE;
    avifDecoder->ignoreExif = AVIF_TRUE;
    avifDecoder->allowProgressive = AVIF_FALSE;
    avifDecoder->allowIncremental = AVIF_FALSE;
    avifDecoder->strictFlags = AVIF_STRICT_DISABLED;
    // TODO(vigneshv): Enable threading based on number of CPU cores available.
    avifDecoder->maxThreads = 1;
 
    // libavif needs a contiguous data buffer.
    sk_sp<SkData> data = nullptr;
    if (stream->getMemoryBase()) {
        // It is safe to make without copy because we'll hold onto the stream.
        data = SkData::MakeWithoutCopy(stream->getMemoryBase(), stream->getLength());
    } else {
        data = SkCopyStreamToData(stream.get());
        // If we are forced to copy the stream to a data, we can go ahead and
        // delete the stream.
        stream.reset(nullptr);
    }
 
    avifResult res = avifDecoderSetIOMemory(avifDecoder.get(), data->bytes(), data->size());
    if (res != AVIF_RESULT_OK) {
        *result = SkCodec::kInternalError;
        return nullptr;
    }
 
    res = avifDecoderParse(avifDecoder.get());
    if (res != AVIF_RESULT_OK) {
        *result = SkCodec::kInvalidInput;
        return nullptr;
    }
 
    std::unique_ptr<SkEncodedInfo::ICCProfile> profile = nullptr;
    // TODO(vigneshv): Get ICC Profile from the avif decoder.
 
    const int bitsPerComponent = avifDecoder->image->depth > 8 ? 16 : 8;
    SkEncodedInfo::Color color;
    SkEncodedInfo::Alpha alpha;
    if (avifDecoder->alphaPresent) {
        color = SkEncodedInfo::kRGBA_Color;
        alpha = SkEncodedInfo::kUnpremul_Alpha;
    } else {
        color = SkEncodedInfo::kRGB_Color;
        alpha = SkEncodedInfo::kOpaque_Alpha;
    }
    SkEncodedInfo info = SkEncodedInfo::Make(avifDecoder->image->width,
                                             avifDecoder->image->height,
                                             color,
                                             alpha,
                                             bitsPerComponent,
                                             std::move(profile),
                                             avifDecoder->image->depth);
    bool animation = avifDecoder->imageCount > 1;
    *result = kSuccess;
    return std::unique_ptr<SkCodec>(new SkAvifCodec(std::move(info),
                                                    std::move(stream),
                                                    std::move(data),
                                                    std::move(avifDecoder),
                                                    kDefault_SkEncodedOrigin,
                                                    animation));
}

◆ onGetEncodedFormat()

SkEncodedImageFormat SkAvifCodec::onGetEncodedFormat ( ) const

inlineoverrideprotectedvirtual

Implements SkCodec.

Definition at line 51 of file SkAvifCodec.h.

51{ return SkEncodedImageFormat::kAVIF; }

SkEncodedImageFormat::kAVIF

@ kAVIF

◆ onGetFrameCount()

int SkAvifCodec::onGetFrameCount ( )

overrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 130 of file SkAvifCodec.cpp.

                                 {
    if (!fUseAnimation) {
        return 1;
    }
 
    if (fFrameHolder.size() == 0) {
        if (fAvifDecoder->imageCount <= 1) {
            fUseAnimation = false;
            return 1;
        }
        fFrameHolder.reserve(fAvifDecoder->imageCount);
        for (int i = 0; i < fAvifDecoder->imageCount; i++) {
            Frame* frame = fFrameHolder.appendNewFrame(fAvifDecoder->alphaPresent == AVIF_TRUE);
            frame->setXYWH(0, 0, fAvifDecoder->image->width, fAvifDecoder->image->height);
            frame->setDisposalMethod(SkCodecAnimation::DisposalMethod::kKeep);
            avifImageTiming timing;
            avifDecoderNthImageTiming(fAvifDecoder.get(), i, &timing);
            frame->setDuration(timing.duration * 1000);
            frame->setRequiredFrame(SkCodec::kNoFrame);
            frame->setHasAlpha(fAvifDecoder->alphaPresent == AVIF_TRUE);
        }
    }
 
    return fFrameHolder.size();
}

◆ onGetFrameInfo()

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

overrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 172 of file SkAvifCodec.cpp.

                                                                  {
    if (i >= fFrameHolder.size()) {
        return false;
    }
 
    const Frame* frame = fFrameHolder.frame(i);
    if (!frame) {
        return false;
    }
 
    if (frameInfo) {
        frame->fillIn(frameInfo, true);
    }
 
    return true;
}

◆ onGetPixels()

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

overrideprotectedvirtual

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 191 of file SkAvifCodec.cpp.

                                                           {
    if (options.fSubset) {
        return kUnimplemented;
    }
 
    const SkColorType dstColorType = dstInfo.colorType();
    if (dstColorType != kRGBA_8888_SkColorType && dstColorType != kRGBA_F16_SkColorType) {
        // TODO(vigneshv): Check if more color types need to be supported.
        // Currently android supports at least RGB565 and BGRA8888 which is not
        // supported here.
        return kUnimplemented;
    }
 
    avifResult result = avifDecoderNthImage(fAvifDecoder.get(), options.fFrameIndex);
    if (result != AVIF_RESULT_OK) {
        return kInvalidInput;
    }
 
    if (this->dimensions() != dstInfo.dimensions()) {
        result = avifImageScale(
                fAvifDecoder->image, dstInfo.width(), dstInfo.height(), &fAvifDecoder->diag);
        if (result != AVIF_RESULT_OK) {
            return kInvalidInput;
        }
    }
 
    avifRGBImage rgbImage;
    avifRGBImageSetDefaults(&rgbImage, fAvifDecoder->image);
 
    if (dstColorType == kRGBA_8888_SkColorType) {
        rgbImage.depth = 8;
    } else if (dstColorType == kRGBA_F16_SkColorType) {
        rgbImage.depth = 16;
        rgbImage.isFloat = AVIF_TRUE;
    }
 
    rgbImage.pixels = static_cast<uint8_t*>(dst);
    rgbImage.rowBytes = dstRowBytes;
    rgbImage.chromaUpsampling = AVIF_CHROMA_UPSAMPLING_FASTEST;
 
    result = avifImageYUVToRGB(fAvifDecoder->image, &rgbImage);
    if (result != AVIF_RESULT_OK) {
        return kInvalidInput;
    }
 
    *rowsDecoded = fAvifDecoder->image->height;
    return kSuccess;
}

◆ onGetRepetitionCount()

int SkAvifCodec::onGetRepetitionCount ( )

overrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 189 of file SkAvifCodec.cpp.

189{ return kRepetitionCountInfinite; }

SkCodec::kRepetitionCountInfinite

static constexpr int kRepetitionCountInfinite

Definition SkCodec.h:759

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

third_party/skia/src/codec/SkAvifCodec.h
third_party/skia/src/codec/SkAvifCodec.cpp

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ getFrameHolder()

◆ IsAvif()

◆ MakeFromStream()

◆ onGetEncodedFormat()

◆ onGetFrameCount()

◆ onGetFrameInfo()

◆ onGetPixels()

◆ onGetRepetitionCount()