SkHeifCodec Class Reference

#include <SkHeifCodec.h>

Inheritance diagram for SkHeifCodec:

Static Public Member Functions
static bool	IsSupported (const void *, size_t, SkEncodedImageFormat *format)
static std::unique_ptr< SkCodec >	MakeFromStream (std::unique_ptr< SkStream >, SkCodec::SelectionPolicy selectionPolicy, 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
bool	conversionSupported (const SkImageInfo &, bool, bool) override
bool	onRewind () override
Protected Member Functions inherited from SkCodec
const SkEncodedInfo &	getEncodedInfo () const
	SkCodec (SkEncodedInfo &&, XformFormat srcFormat, std::unique_ptr< SkStream >, SkEncodedOrigin=kTopLeft_SkEncodedOrigin)
void	setSrcXformFormat (XformFormat pixelFormat)
XformFormat	getSrcXformFormat () const
virtual bool	onGetGainmapInfo (SkGainmapInfo *, std::unique_ptr< SkStream > *)
virtual SkISize	onGetScaledDimensions (float) const
virtual bool	onDimensionsSupported (const SkISize &)
virtual 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 ()

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 25 of file SkHeifCodec.h.

Member Function Documentation

conversionSupported()

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

overrideprotectedvirtual

Return whether we can convert to dst.

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

Reimplemented from SkCodec.

Definition at line 231 of file SkHeifCodec.cpp.

                                                            {
    SkASSERT(srcIsOpaque);
 
    if (kUnknown_SkAlphaType == dstInfo.alphaType()) {
        return false;
    }
 
    if (kOpaque_SkAlphaType != dstInfo.alphaType()) {
        SkCodecPrintf("Warning: an opaque image should be decoded as opaque "
                "- it is being decoded as non-opaque, which will draw slower\n");
    }
 
    uint8_t colorDepth = fHeifDecoder->getColorDepth();
    switch (dstInfo.colorType()) {
        case kRGBA_8888_SkColorType:
            this->setSrcXformFormat(skcms_PixelFormat_RGBA_8888);
            return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);
 
        case kBGRA_8888_SkColorType:
            this->setSrcXformFormat(skcms_PixelFormat_RGBA_8888);
            return fHeifDecoder->setOutputColor(kHeifColorFormat_BGRA_8888);
 
        case kRGB_565_SkColorType:
            this->setSrcXformFormat(skcms_PixelFormat_RGBA_8888);
            if (needsColorXform) {
                return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);
            } else {
                return fHeifDecoder->setOutputColor(kHeifColorFormat_RGB565);
            }
 
        case kRGBA_1010102_SkColorType:
            this->setSrcXformFormat(skcms_PixelFormat_RGBA_1010102);
            return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_1010102);
 
        case kRGBA_F16_SkColorType:
            SkASSERT(needsColorXform);
            if (srcIsOpaque && colorDepth == 10) {
                this->setSrcXformFormat(skcms_PixelFormat_RGBA_1010102);
                return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_1010102);
            } else {
                this->setSrcXformFormat(skcms_PixelFormat_RGBA_8888);
                return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);
            }
 
        default:
            return false;
    }
}

getFrameHolder()

const SkFrameHolder * SkHeifCodec::getFrameHolder ( ) const

inlineoverrideprotectedvirtual

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

Reimplemented from SkCodec.

Definition at line 56 of file SkHeifCodec.h.

                                                         {
        return &fFrameHolder;
    }

IsSupported()

bool SkHeifCodec::IsSupported ( const void *  buffer, size_t  bytesRead, SkEncodedImageFormat *  format  )

static

Definition at line 21 of file SkHeifCodec.cpp.

                                                            {
    // Parse the ftyp box up to bytesRead to determine if this is HEIF or AVIF.
    // Any valid ftyp box should have at least 8 bytes.
    if (bytesRead < 8) {
        return false;
    }
 
    const uint32_t* ptr = (const uint32_t*)buffer;
    uint64_t chunkSize = SkEndian_SwapBE32(ptr[0]);
    uint32_t chunkType = SkEndian_SwapBE32(ptr[1]);
 
    if (chunkType != FOURCC('f', 't', 'y', 'p')) {
        return false;
    }
 
    int64_t offset = 8;
    if (chunkSize == 1) {
        // This indicates that the next 8 bytes represent the chunk size,
        // and chunk data comes after that.
        if (bytesRead < 16) {
            return false;
        }
        auto* chunkSizePtr = SkTAddOffset<const uint64_t>(buffer, offset);
        chunkSize = SkEndian_SwapBE64(*chunkSizePtr);
        if (chunkSize < 16) {
            // The smallest valid chunk is 16 bytes long in this case.
            return false;
        }
        offset += 8;
    } else if (chunkSize < 8) {
        // The smallest valid chunk is 8 bytes long.
        return false;
    }
 
    if (chunkSize > bytesRead) {
        chunkSize = bytesRead;
    }
    int64_t chunkDataSize = chunkSize - offset;
    // It should at least have major brand (4-byte) and minor version (4-bytes).
    // The rest of the chunk (if any) is a list of (4-byte) compatible brands.
    if (chunkDataSize < 8) {
        return false;
    }
 
    uint32_t numCompatibleBrands = (chunkDataSize - 8) / 4;
    bool isHeif = false;
    for (size_t i = 0; i < numCompatibleBrands + 2; ++i) {
        if (i == 1) {
            // Skip this index, it refers to the minorVersion,
            // not a brand.
            continue;
        }
        auto* brandPtr = SkTAddOffset<const uint32_t>(buffer, offset + 4 * i);
        uint32_t brand = SkEndian_SwapBE32(*brandPtr);
        if (brand == FOURCC('m', 'i', 'f', '1') || brand == FOURCC('h', 'e', 'i', 'c')
         || brand == FOURCC('m', 's', 'f', '1') || brand == FOURCC('h', 'e', 'v', 'c')
         || brand == FOURCC('a', 'v', 'i', 'f') || brand == FOURCC('a', 'v', 'i', 's')) {
            // AVIF files could have "mif1" as the major brand. So we cannot
            // distinguish whether the image is AVIF or HEIC just based on the
            // "mif1" brand. So wait until we see a specific avif brand to
            // determine whether it is AVIF or HEIC.
            isHeif = true;
            if (brand == FOURCC('a', 'v', 'i', 'f')
              || brand == FOURCC('a', 'v', 'i', 's')) {
                if (format != nullptr) {
                    *format = SkEncodedImageFormat::kAVIF;
                }
                return true;
            }
        }
    }
    if (isHeif) {
        if (format != nullptr) {
            *format = SkEncodedImageFormat::kHEIF;
        }
        return true;
    }
    return false;
}

MakeFromStream()

std::unique_ptr< SkCodec > SkHeifCodec::MakeFromStream ( std::unique_ptr< SkStream >  stream, SkCodec::SelectionPolicy  selectionPolicy, Result *  result  )

static

Definition at line 145 of file SkHeifCodec.cpp.

                                                                {
    SkASSERT(result);
    if (!stream) {
        *result = SkCodec::kInvalidInput;
        return nullptr;
    }
    std::unique_ptr<HeifDecoder> heifDecoder(createHeifDecoder());
    if (heifDecoder == nullptr) {
        *result = SkCodec::kInternalError;
        return nullptr;
    }
 
    constexpr size_t bytesToRead = MinBufferedBytesNeeded();
    char buffer[bytesToRead];
    size_t bytesRead = stream->peek(buffer, bytesToRead);
    if (0 == bytesRead) {
        // 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");
            *result = kCouldNotRewind;
            return nullptr;
        }
    }
 
    SkEncodedImageFormat format;
    if (!SkHeifCodec::IsSupported(buffer, bytesRead, &format)) {
        SkCodecPrintf("Failed to get format despite earlier detecting it");
        *result = SkCodec::kInternalError;
        return nullptr;
    }
 
    HeifFrameInfo heifInfo;
    if (!heifDecoder->init(new SkHeifStreamWrapper(stream.release()), &heifInfo)) {
        *result = SkCodec::kInvalidInput;
        return nullptr;
    }
 
    size_t frameCount = 1;
    if (selectionPolicy == SkCodec::SelectionPolicy::kPreferAnimation) {
        HeifFrameInfo sequenceInfo;
        if (heifDecoder->getSequenceInfo(&sequenceInfo, &frameCount) &&
                frameCount > 1) {
            heifInfo = std::move(sequenceInfo);
        }
    }
 
    std::unique_ptr<SkEncodedInfo::ICCProfile> profile = nullptr;
    if (heifInfo.mIccData.size() > 0) {
        auto iccData = new std::vector<uint8_t>(std::move(heifInfo.mIccData));
        auto icc = SkData::MakeWithProc(iccData->data(), iccData->size(), releaseProc, iccData);
        profile = SkEncodedInfo::ICCProfile::Make(std::move(icc));
    }
    if (profile && profile->profile()->data_color_space != skcms_Signature_RGB) {
        // This will result in sRGB.
        profile = nullptr;
    }
 
    uint8_t colorDepth = heifDecoder->getColorDepth();
 
    SkEncodedInfo info = SkEncodedInfo::Make(heifInfo.mWidth, heifInfo.mHeight,
            SkEncodedInfo::kYUV_Color, SkEncodedInfo::kOpaque_Alpha,
            /*bitsPerComponent*/ 8, std::move(profile), colorDepth);
    SkEncodedOrigin orientation = get_orientation(heifInfo);
 
    *result = SkCodec::kSuccess;
    return std::unique_ptr<SkCodec>(new SkHeifCodec(
            std::move(info), heifDecoder.release(), orientation, frameCount > 1, format));
}

onGetEncodedFormat()

SkEncodedImageFormat SkHeifCodec::onGetEncodedFormat ( ) const

inlineoverrideprotectedvirtual

Implements SkCodec.

Definition at line 49 of file SkHeifCodec.h.

                                                             {
        return fFormat;
    }

onGetFrameCount()

int SkHeifCodec::onGetFrameCount ( )

overrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 333 of file SkHeifCodec.cpp.

                                 {
    if (!fUseAnimation) {
        return 1;
    }
 
    if (fFrameHolder.size() == 0) {
        size_t frameCount;
        HeifFrameInfo frameInfo;
        if (!fHeifDecoder->getSequenceInfo(&frameInfo, &frameCount)
                || frameCount <= 1) {
            fUseAnimation = false;
            return 1;
        }
        fFrameHolder.reserve(frameCount);
        for (size_t i = 0; i < frameCount; i++) {
            Frame* frame = fFrameHolder.appendNewFrame();
            frame->setXYWH(0, 0, frameInfo.mWidth, frameInfo.mHeight);
            frame->setDisposalMethod(SkCodecAnimation::DisposalMethod::kKeep);
            // Currently we don't know the duration until the frame is actually
            // decoded (onGetFrameInfo is also called before frame is decoded).
            // For now, fill it base on the value reported for the sequence.
            frame->setDuration(frameInfo.mDurationUs / 1000);
            frame->setRequiredFrame(SkCodec::kNoFrame);
            frame->setHasAlpha(false);
        }
    }
 
    return fFrameHolder.size();
}

onGetFrameInfo()

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

overrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 383 of file SkHeifCodec.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 SkHeifCodec::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 407 of file SkHeifCodec.cpp.

                                                           {
    if (options.fSubset) {
        // Not supporting subsets on this path for now.
        // TODO: if the heif has tiles, we can support subset here, but
        // need to retrieve tile config from metadata retriever first.
        return kUnimplemented;
    }
 
    bool success;
    if (fUseAnimation) {
        success = fHeifDecoder->decodeSequence(options.fFrameIndex, &fFrameInfo);
        fFrameHolder.editFrameAt(options.fFrameIndex)->setDuration(
                fFrameInfo.mDurationUs / 1000);
    } else {
        success = fHeifDecoder->decode(&fFrameInfo);
    }
 
    if (!success) {
        return kInvalidInput;
    }
 
    fSwizzler.reset(nullptr);
    this->allocateStorage(dstInfo);
 
    int rows = this->readRows(dstInfo, dst, dstRowBytes, dstInfo.height(), options);
    if (rows < dstInfo.height()) {
        *rowsDecoded = rows;
        return kIncompleteInput;
    }
 
    return kSuccess;
}

onGetRepetitionCount()

int SkHeifCodec::onGetRepetitionCount ( )

overrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 400 of file SkHeifCodec.cpp.

                                      {
    return kRepetitionCountInfinite;
}

onRewind()

bool SkHeifCodec::onRewind ( )

overrideprotectedvirtual

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

Subclasses should do any set up needed after a rewind.

Reimplemented from SkCodec.

Definition at line 502 of file SkHeifCodec.cpp.

                           {
    fSwizzler.reset(nullptr);
    fSwizzleSrcRow = nullptr;
    fColorXformSrcRow = nullptr;
    fStorage.reset();
 
    return true;
}

---

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

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