#include <SkIcoCodec.h>

Inheritance diagram for SkIcoCodec:

Static Public Member Functions
static bool	IsIco (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
SkISize	onGetScaledDimensions (float desiredScale) const override

bool	onDimensionsSupported (const SkISize &) override

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

SkEncodedImageFormat	onGetEncodedFormat () const override

SkScanlineOrder	onGetScanlineOrder () const override

bool	conversionSupported (const SkImageInfo &, bool, bool) override

bool	usesColorXform () const 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 27 of file SkIcoCodec.h.

Member Function Documentation

◆ conversionSupported()

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

inlineoverrideprotectedvirtual

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 59 of file SkIcoCodec.h.

                                                                      {
        // This will be checked by the embedded codec.
        return true;
    }

◆ IsIco()

bool SkIcoCodec::IsIco	(	const void *	buffer,
		size_t	bytesRead
	)

static

Definition at line 37 of file SkIcoCodec.cpp.

                                                           {
    const char icoSig[] = { '\x00', '\x00', '\x01', '\x00' };
    const char curSig[] = { '\x00', '\x00', '\x02', '\x00' };
    return bytesRead >= sizeof(icoSig) &&
            (!memcmp(buffer, icoSig, sizeof(icoSig)) ||
            !memcmp(buffer, curSig, sizeof(curSig)));
}

◆ MakeFromStream()

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

static

Definition at line 45 of file SkIcoCodec.cpp.

                                                                    {
    SkASSERT(result);
    if (!stream) {
        *result = SkCodec::kInvalidInput;
        return nullptr;
    }
    // It is helpful to have the entire stream in a contiguous buffer. In some cases,
    // this is already the case anyway, so this method is faster. In others, this is
    // safer than the old method, which required allocating a block of memory whose
    // byte size is stored in the stream as a uint32_t, and may result in a large or
    // failed allocation.
    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);
    }
 
    // Header size constants
    constexpr uint32_t kIcoDirectoryBytes = 6;
    constexpr uint32_t kIcoDirEntryBytes = 16;
 
    // Read the directory header
    if (data->size() < kIcoDirectoryBytes) {
        SkCodecPrintf("Error: unable to read ico directory header.\n");
        *result = kIncompleteInput;
        return nullptr;
    }
 
    // Process the directory header
    const uint16_t numImages = get_short(data->bytes(), 4);
    if (0 == numImages) {
        SkCodecPrintf("Error: No images embedded in ico.\n");
        *result = kInvalidInput;
        return nullptr;
    }
 
    // This structure is used to represent the vital information about entries
    // in the directory header.  We will obtain this information for each
    // directory entry.
    struct Entry {
        uint32_t offset;
        uint32_t size;
    };
    UniqueVoidPtr dirEntryBuffer(sk_malloc_canfail(sizeof(Entry) * numImages));
    if (!dirEntryBuffer) {
        SkCodecPrintf("Error: OOM allocating ICO directory for %i images.\n",
                      numImages);
        *result = kInternalError;
        return nullptr;
    }
    auto* directoryEntries = reinterpret_cast<Entry*>(dirEntryBuffer.get());
 
    // Iterate over directory entries
    for (uint32_t i = 0; i < numImages; i++) {
        const uint8_t* entryBuffer = data->bytes() + kIcoDirectoryBytes + i * kIcoDirEntryBytes;
        if (data->size() < kIcoDirectoryBytes + (i+1) * kIcoDirEntryBytes) {
            SkCodecPrintf("Error: Dir entries truncated in ico.\n");
            *result = kIncompleteInput;
            return nullptr;
        }
 
        // The directory entry contains information such as width, height,
        // bits per pixel, and number of colors in the color palette.  We will
        // ignore these fields since they are repeated in the header of the
        // embedded image.  In the event of an inconsistency, we would always
        // defer to the value in the embedded header anyway.
 
        // Specifies the size of the embedded image, including the header
        uint32_t size = get_int(entryBuffer, 8);
 
        // Specifies the offset of the embedded image from the start of file.
        // It does not indicate the start of the pixel data, but rather the
        // start of the embedded image header.
        uint32_t offset = get_int(entryBuffer, 12);
 
        // Save the vital fields
        directoryEntries[i].offset = offset;
        directoryEntries[i].size = size;
    }
 
    // Default Result, if no valid embedded codecs are found.
    *result = kInvalidInput;
 
    // It is "customary" that the embedded images will be stored in order of
    // increasing offset.  However, the specification does not indicate that
    // they must be stored in this order, so we will not trust that this is the
    // case.  Here we sort the embedded images by increasing offset.
    struct EntryLessThan {
        bool operator() (Entry a, Entry b) const {
            return a.offset < b.offset;
        }
    };
    EntryLessThan lessThan;
    SkTQSort(directoryEntries, directoryEntries + numImages, lessThan);
 
    // Now will construct a candidate codec for each of the embedded images
    uint32_t bytesRead = kIcoDirectoryBytes + numImages * kIcoDirEntryBytes;
    auto codecs = std::make_unique<TArray<std::unique_ptr<SkCodec>>>(numImages);
    for (uint32_t i = 0; i < numImages; i++) {
        uint32_t offset = directoryEntries[i].offset;
        uint32_t size = directoryEntries[i].size;
 
        // Ensure that the offset is valid
        if (offset < bytesRead) {
            SkCodecPrintf("Warning: invalid ico offset.\n");
            continue;
        }
 
        // If we cannot skip, assume we have reached the end of the stream and
        // stop trying to make codecs
        if (offset >= data->size()) {
            SkCodecPrintf("Warning: could not skip to ico offset.\n");
            break;
        }
        bytesRead = offset;
 
        if (offset + size > data->size()) {
            SkCodecPrintf("Warning: could not create embedded stream.\n");
            *result = kIncompleteInput;
            break;
        }
 
        sk_sp<SkData> embeddedData(SkData::MakeSubset(data.get(), offset, size));
        auto embeddedStream = SkMemoryStream::Make(embeddedData);
        bytesRead += size;
 
        // Check if the embedded codec is bmp or png and create the codec
        std::unique_ptr<SkCodec> codec;
        Result ignoredResult;
        if (SkPngCodec::IsPng(embeddedData->bytes(), embeddedData->size())) {
            codec = SkPngCodec::MakeFromStream(std::move(embeddedStream), &ignoredResult);
        } else {
            codec = SkBmpCodec::MakeFromIco(std::move(embeddedStream), &ignoredResult);
        }
 
        if (nullptr != codec) {
            codecs->push_back(std::move(codec));
        }
    }
 
    if (codecs->empty()) {
        SkCodecPrintf("Error: could not find any valid embedded ico codecs.\n");
        return nullptr;
    }
 
    // Use the largest codec as a "suggestion" for image info
    size_t maxSize = 0;
    int maxIndex = 0;
    for (int i = 0; i < codecs->size(); i++) {
        SkImageInfo info = codecs->at(i)->getInfo();
        size_t size = info.computeMinByteSize();
 
        if (size > maxSize) {
            maxSize = size;
            maxIndex = i;
        }
    }
 
    auto maxInfo = codecs->at(maxIndex)->getEncodedInfo().copy();
 
    *result = kSuccess;
    return std::unique_ptr<SkCodec>(
            new SkIcoCodec(std::move(maxInfo), std::move(stream), std::move(codecs)));
}

◆ onDimensionsSupported()

bool SkIcoCodec::onDimensionsSupported ( const SkISize & )

overrideprotectedvirtual

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

Reimplemented from SkCodec.

Definition at line 266 of file SkIcoCodec.cpp.

                                                         {
    return this->chooseCodec(dim, 0) >= 0;
}

◆ onGetEncodedFormat()

SkEncodedImageFormat SkIcoCodec::onGetEncodedFormat ( ) const

inlineoverrideprotectedvirtual

Implements SkCodec.

Definition at line 53 of file SkIcoCodec.h.

                                                             {
        return SkEncodedImageFormat::kICO;
    }

◆ onGetPixels()

SkCodec::Result SkIcoCodec::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 273 of file SkIcoCodec.cpp.

                                                          {
    if (opts.fSubset) {
        // Subsets are not supported.
        return kUnimplemented;
    }
 
    int index = 0;
    SkCodec::Result result = kInvalidScale;
    while (true) {
        index = this->chooseCodec(dstInfo.dimensions(), index);
        if (index < 0) {
            break;
        }
 
        SkCodec* embeddedCodec = fEmbeddedCodecs->at(index).get();
        result = embeddedCodec->getPixels(dstInfo, dst, dstRowBytes, &opts);
        switch (result) {
            case kSuccess:
            case kIncompleteInput:
                // The embedded codec will handle filling incomplete images, so we will indicate
                // that all of the rows are initialized.
                *rowsDecoded = dstInfo.height();
                return result;
            default:
                // Continue trying to find a valid embedded codec on a failed decode.
                break;
        }
 
        index++;
    }
 
    SkCodecPrintf("Error: No matching candidate image in ico.\n");
    return result;
}

◆ onGetScaledDimensions()

SkISize SkIcoCodec::onGetScaledDimensions ( float desiredScale ) const

overrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 228 of file SkIcoCodec.cpp.

                                                                  {
    // We set the dimensions to the largest candidate image by default.
    // Regardless of the scale request, this is the largest image that we
    // will decode.
    int origWidth = this->dimensions().width();
    int origHeight = this->dimensions().height();
    float desiredSize = desiredScale * origWidth * origHeight;
    // At least one image will have smaller error than this initial value
    float minError = ((float) (origWidth * origHeight)) - desiredSize + 1.0f;
    int32_t minIndex = -1;
    for (int32_t i = 0; i < fEmbeddedCodecs->size(); i++) {
        auto dimensions = fEmbeddedCodecs->at(i)->dimensions();
        int width = dimensions.width();
        int height = dimensions.height();
        float error = SkTAbs(((float) (width * height)) - desiredSize);
        if (error < minError) {
            minError = error;
            minIndex = i;
        }
    }
    SkASSERT(minIndex >= 0);
 
    return fEmbeddedCodecs->at(minIndex)->dimensions();
}

◆ onGetScanlineOrder()

SkCodec::SkScanlineOrder SkIcoCodec::onGetScanlineOrder ( ) const

overrideprotectedvirtual

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

Reimplemented from SkCodec.

Definition at line 394 of file SkIcoCodec.cpp.

                                                            {
    // FIXME: This function will possibly return the wrong value if it is called
    //        before startScanlineDecode()/startIncrementalDecode().
    if (fCurrCodec) {
        return fCurrCodec->getScanlineOrder();
    }
 
    return INHERITED::onGetScanlineOrder();
}

◆ usesColorXform()

bool SkIcoCodec::usesColorXform ( ) const

inlineoverrideprotectedvirtual

Reimplemented from SkCodec.

Definition at line 65 of file SkIcoCodec.h.

65{ return false; }

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

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

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ conversionSupported()

◆ IsIco()

◆ MakeFromStream()

◆ onDimensionsSupported()

◆ onGetEncodedFormat()

◆ onGetPixels()

◆ onGetScaledDimensions()

◆ onGetScanlineOrder()

◆ usesColorXform()