SkAndroidCodec Class Reference

#include <SkAndroidCodec.h>

Inheritance diagram for SkAndroidCodec:

Classes
struct	AndroidOptions

Public Types
enum class	ExifOrientationBehavior { kIgnore , kRespect }

Public Member Functions
virtual	~SkAndroidCodec ()
const SkImageInfo &	getInfo () const
const skcms_ICCProfile *	getICCProfile () const
SkEncodedImageFormat	getEncodedFormat () const
SkColorType	computeOutputColorType (SkColorType requestedColorType)
SkAlphaType	computeOutputAlphaType (bool requestedUnpremul)
sk_sp< SkColorSpace >	computeOutputColorSpace (SkColorType outputColorType, sk_sp< SkColorSpace > prefColorSpace=nullptr)
int	computeSampleSize (SkISize *size) const
SkISize	getSampledDimensions (int sampleSize) const
bool	getSupportedSubset (SkIRect *desiredSubset) const
SkISize	getSampledSubsetDimensions (int sampleSize, const SkIRect &subset) const
SkCodec::Result	getAndroidPixels (const SkImageInfo &info, void *pixels, size_t rowBytes, const AndroidOptions *options)
SkCodec::Result	getAndroidPixels (const SkImageInfo &info, void *pixels, size_t rowBytes)
SkCodec::Result	getPixels (const SkImageInfo &info, void *pixels, size_t rowBytes)
SkCodec *	codec () const
bool	getAndroidGainmap (SkGainmapInfo *outInfo, std::unique_ptr< SkStream > *outGainmapImageStream)

Static Public Member Functions
static std::unique_ptr< SkAndroidCodec >	MakeFromCodec (std::unique_ptr< SkCodec >)
static std::unique_ptr< SkAndroidCodec >	MakeFromStream (std::unique_ptr< SkStream >, SkPngChunkReader *=nullptr)
static std::unique_ptr< SkAndroidCodec >	MakeFromData (sk_sp< SkData >, SkPngChunkReader *=nullptr)

Protected Member Functions
	SkAndroidCodec (SkCodec *)
virtual SkISize	onGetSampledDimensions (int sampleSize) const =0
virtual bool	onGetSupportedSubset (SkIRect *desiredSubset) const =0
virtual SkCodec::Result	onGetAndroidPixels (const SkImageInfo &info, void *pixels, size_t rowBytes, const AndroidOptions &options)=0

Detailed Description

Abstract interface defining image codec functionality that is necessary for Android.

Definition at line 39 of file SkAndroidCodec.h.

Member Enumeration Documentation

ExifOrientationBehavior

enum class SkAndroidCodec::ExifOrientationBehavior

strong

Deprecated.

Now that SkAndroidCodec supports multiframe images, there are multiple ways to handle compositing an oriented frame on top of an oriented frame with different tradeoffs. SkAndroidCodec now ignores the orientation and forces the client to handle it.

Enumerator
kIgnore
kRespect

Definition at line 49 of file SkAndroidCodec.h.

                                       {
        kIgnore,
        kRespect,
    };

Constructor & Destructor Documentation

~SkAndroidCodec()

SkAndroidCodec::~SkAndroidCodec ( )

virtual

Definition at line 204 of file SkAndroidCodec.cpp.

{}

SkAndroidCodec()

SkAndroidCodec::SkAndroidCodec ( SkCodec *  codec )

protected

Definition at line 199 of file SkAndroidCodec.cpp.

    : fInfo(codec->getInfo())
    , fCodec(codec)
{}

Member Function Documentation

codec()

SkCodec * SkAndroidCodec::codec ( ) const

inline

Definition at line 264 of file SkAndroidCodec.h.

{ return fCodec.get(); }

computeOutputAlphaType()

SkAlphaType SkAndroidCodec::computeOutputAlphaType

(

bool

requestedUnpremul

)

Parameters

requestedUnpremul

Indicates if the client requested unpremultiplied output

Returns the appropriate alpha type to decode to. If the image has alpha, the value of requestedUnpremul will be honored.

Definition at line 297 of file SkAndroidCodec.cpp.

                                                                         {
    if (kOpaque_SkAlphaType == this->getInfo().alphaType()) {
        return kOpaque_SkAlphaType;
    }
    return requestedUnpremul ? kUnpremul_SkAlphaType : kPremul_SkAlphaType;
}

computeOutputColorSpace()

sk_sp< SkColorSpace > SkAndroidCodec::computeOutputColorSpace	(	SkColorType	outputColorType,
		sk_sp< SkColorSpace >	prefColorSpace = nullptr
	)

Parameters

outputColorType	Color type that the client will decode to.
prefColorSpace	Preferred color space to decode to. This may not return |prefColorSpace| for specific color types.

Returns the appropriate color space to decode to.

Definition at line 304 of file SkAndroidCodec.cpp.

                                                                                                {
    switch (outputColorType) {
        case kRGBA_F16_SkColorType:
        case kRGB_565_SkColorType:
        case kRGBA_8888_SkColorType:
        case kBGRA_8888_SkColorType:
        case kRGBA_1010102_SkColorType: {
            // If |prefColorSpace| is supplied, choose it.
            if (prefColorSpace) {
                return prefColorSpace;
            }
 
            const skcms_ICCProfile* encodedProfile = fCodec->getEncodedInfo().profile();
            if (encodedProfile) {
                // Prefer CICP information if it exists.
                if (encodedProfile->has_CICP) {
                    const auto cicpColorSpace =
                            cicp_get_sk_color_space(encodedProfile->CICP.color_primaries,
                                                    encodedProfile->CICP.transfer_characteristics,
                                                    encodedProfile->CICP.matrix_coefficients,
                                                    encodedProfile->CICP.video_full_range_flag);
                    if (cicpColorSpace) {
                        return cicpColorSpace;
                    }
                }
                if (auto encodedSpace = SkColorSpace::Make(*encodedProfile)) {
                    // Leave the pixels in the encoded color space.  Color space conversion
                    // will be handled after decode time.
                    return encodedSpace;
                }
 
                if (encodedProfile->has_toXYZD50) {
                    return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
                                                 encodedProfile->toXYZD50);
                }
            }
 
            return SkColorSpace::MakeSRGB();
        }
        default:
            // Color correction not supported for kGray.
            return nullptr;
    }
}

computeOutputColorType()

SkColorType SkAndroidCodec::computeOutputColorType

(

SkColorType

requestedColorType

)

Parameters

requestedColorType

Color type requested by the client

|requestedColorType| may be overriden. We will default to kF16 for high precision images.

In the general case, if it is possible to decode to |requestedColorType|, this returns |requestedColorType|. Otherwise, this returns a color type that is an appropriate match for the the encoded data.

Definition at line 259 of file SkAndroidCodec.cpp.

                                                                                 {
    bool highPrecision = fCodec->getEncodedInfo().bitsPerComponent() > 8;
    uint8_t colorDepth = fCodec->getEncodedInfo().getColorDepth();
    switch (requestedColorType) {
        case kARGB_4444_SkColorType:
            return kN32_SkColorType;
        case kN32_SkColorType:
            break;
        case kAlpha_8_SkColorType:
            // Fall through to kGray_8.  Before kGray_8_SkColorType existed,
            // we allowed clients to request kAlpha_8 when they wanted a
            // grayscale decode.
        case kGray_8_SkColorType:
            if (kGray_8_SkColorType == this->getInfo().colorType()) {
                return kGray_8_SkColorType;
            }
            break;
        case kRGB_565_SkColorType:
            if (kOpaque_SkAlphaType == this->getInfo().alphaType()) {
                return kRGB_565_SkColorType;
            }
            break;
        case kRGBA_1010102_SkColorType:
            if (colorDepth == 10) {
              return kRGBA_1010102_SkColorType;
            }
            break;
        case kRGBA_F16_SkColorType:
            return kRGBA_F16_SkColorType;
        default:
            break;
    }
 
    // F16 is the Android default for high precision images.
    return highPrecision ? kRGBA_F16_SkColorType :
        (colorDepth == 10 ? kRGBA_1010102_SkColorType : kN32_SkColorType);
}

computeSampleSize()

int SkAndroidCodec::computeSampleSize

(

SkISize *

size

)

const

Compute the appropriate sample size to get to |size|.

Parameters

size	As an input parameter, the desired output size of the decode. As an output parameter, the smallest sampled size larger than the input.

Returns

the sample size to set AndroidOptions::fSampleSize to decode to the output |size|.

Definition at line 367 of file SkAndroidCodec.cpp.

                                                                {
    SkASSERT(desiredSize);
 
    const auto origDims = fCodec->dimensions();
    if (!desiredSize || *desiredSize == origDims) {
        return 1;
    }
 
    if (smaller_than(origDims, *desiredSize)) {
        *desiredSize = origDims;
        return 1;
    }
 
    // Handle bad input:
    if (desiredSize->width() < 1 || desiredSize->height() < 1) {
        *desiredSize = SkISize::Make(std::max(1, desiredSize->width()),
                                     std::max(1, desiredSize->height()));
    }
 
    if (supports_any_down_scale(fCodec.get())) {
        return 1;
    }
 
    int sampleX = origDims.width()  / desiredSize->width();
    int sampleY = origDims.height() / desiredSize->height();
    int sampleSize = std::min(sampleX, sampleY);
    auto computedSize = this->getSampledDimensions(sampleSize);
    if (computedSize == *desiredSize) {
        return sampleSize;
    }
 
    if (computedSize == origDims || sampleSize == 1) {
        // Cannot downscale
        *desiredSize = computedSize;
        return 1;
    }
 
    if (strictly_bigger_than(computedSize, *desiredSize)) {
        // See if there is a tighter fit.
        while (true) {
            auto smaller = this->getSampledDimensions(sampleSize + 1);
            if (smaller == *desiredSize) {
                return sampleSize + 1;
            }
            if (smaller == computedSize || smaller_than(smaller, *desiredSize)) {
                // Cannot get any smaller without being smaller than desired.
                *desiredSize = computedSize;
                return sampleSize;
            }
 
            sampleSize++;
            computedSize = smaller;
        }
 
        SkASSERT(false);
    }
 
    if (!smaller_than(computedSize, *desiredSize)) {
        // This means one of the computed dimensions is equal to desired, and
        // the other is bigger. This is as close as we can get.
        *desiredSize = computedSize;
        return sampleSize;
    }
 
    // computedSize is too small. Make it larger.
    while (sampleSize > 2) {
        auto bigger = this->getSampledDimensions(sampleSize - 1);
        if (bigger == *desiredSize || !smaller_than(bigger, *desiredSize)) {
            *desiredSize = bigger;
            return sampleSize - 1;
        }
        sampleSize--;
    }
 
    *desiredSize = origDims;
    return 1;
}

getAndroidGainmap()

bool SkAndroidCodec::getAndroidGainmap	(	SkGainmapInfo *	outInfo,
		std::unique_ptr< SkStream > *	outGainmapImageStream
	)

Retrieve the gainmap for an image.

Parameters

outInfo	On success, this is populated with the parameters for rendering this gainmap. This parameter must be non-nullptr.
outGainmapImageStream	On success, this is populated with a stream from which the gainmap image may be decoded. This parameter is optional, and may be set to nullptr.

Returns

If this has a gainmap image and that gainmap image was successfully extracted then return true. Otherwise return false.

Definition at line 544 of file SkAndroidCodec.cpp.

                                                                                       {
    return fCodec->onGetGainmapInfo(info, outGainmapImageStream);
}

getAndroidPixels() [1/2]

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

Simplified version of getAndroidPixels() where we supply the default AndroidOptions as specified above for AndroidOptions. It will not perform any scaling or subsetting.

Definition at line 539 of file SkAndroidCodec.cpp.

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

getAndroidPixels() [2/2]

SkCodec::Result SkAndroidCodec::getAndroidPixels	(	const SkImageInfo &	info,
		void *	pixels,
		size_t	rowBytes,
		const AndroidOptions *	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 or subset. If the codec cannot perform this scaling or subsetting, it will return an error code.

The AndroidOptions object is also used to specify any requested scaling or subsetting using options->fSampleSize and options->fSubset. If NULL, the defaults (as specified above for AndroidOptions) are used.

Returns

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

Definition at line 490 of file SkAndroidCodec.cpp.

                                                                                    {
    if (!requestPixels) {
        return SkCodec::kInvalidParameters;
    }
    if (requestRowBytes < requestInfo.minRowBytes()) {
        return SkCodec::kInvalidParameters;
    }
 
    AndroidOptions defaultOptions;
    if (!options) {
        options = &defaultOptions;
    } else {
        if (options->fSubset) {
            if (!is_valid_subset(*options->fSubset, fCodec->dimensions())) {
                return SkCodec::kInvalidParameters;
            }
 
            if (SkIRect::MakeSize(fCodec->dimensions()) == *options->fSubset) {
                // The caller wants the whole thing, rather than a subset. Modify
                // the AndroidOptions passed to onGetAndroidPixels to not specify
                // a subset.
                defaultOptions = *options;
                defaultOptions.fSubset = nullptr;
                options = &defaultOptions;
            }
        }
    }
 
    // We may need to have handleFrameIndex recursively call this method
    // to resolve one frame depending on another. The recursion stops
    // when we find a frame which does not require an earlier frame
    // e.g. frame->getRequiredFrame() returns kNoFrame
    auto getPixelsFn = [&](const SkImageInfo& info, void* pixels, size_t rowBytes,
                           const SkCodec::Options& opts, int requiredFrame
                           ) -> SkCodec::Result {
        SkAndroidCodec::AndroidOptions prevFrameOptions(
                        reinterpret_cast<const SkAndroidCodec::AndroidOptions&>(opts));
        prevFrameOptions.fFrameIndex = requiredFrame;
        return this->getAndroidPixels(info, pixels, rowBytes, &prevFrameOptions);
    };
    if (auto result = fCodec->handleFrameIndex(requestInfo, requestPixels, requestRowBytes,
            *options, getPixelsFn); result != SkCodec::kSuccess) {
        return result;
    }
 
    return this->onGetAndroidPixels(requestInfo, requestPixels, requestRowBytes, *options);
}

getEncodedFormat()

SkEncodedImageFormat SkAndroidCodec::getEncodedFormat ( ) const

inline

Format of the encoded data.

Definition at line 97 of file SkAndroidCodec.h.

{ return fCodec->getEncodedFormat(); }

getICCProfile()

const skcms_ICCProfile * SkAndroidCodec::getICCProfile ( ) const

inline

Return the ICC profile of the encoded data.

Definition at line 90 of file SkAndroidCodec.h.

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

getInfo()

const SkImageInfo & SkAndroidCodec::getInfo ( ) const

inline

Definition at line 85 of file SkAndroidCodec.h.

{ return fInfo; }

getPixels()

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

inline

Definition at line 260 of file SkAndroidCodec.h.

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

getSampledDimensions()

SkISize SkAndroidCodec::getSampledDimensions

(

int

sampleSize

)

const

Returns the dimensions of the scaled output image, for an input sampleSize.

When the sample size divides evenly into the original dimensions, the scaled output dimensions will simply be equal to the original dimensions divided by the sample size.

When the sample size does not divide even into the original dimensions, the codec may round up or down, depending on what is most efficient to decode.

Finally, the codec will always recommend a non-zero output, so the output dimension will always be one if the sampleSize is greater than the original dimension.

Definition at line 445 of file SkAndroidCodec.cpp.

                                                                 {
    if (!is_valid_sample_size(sampleSize)) {
        return {0, 0};
    }
 
    // Fast path for when we are not scaling.
    if (1 == sampleSize) {
        return fCodec->dimensions();
    }
 
    return this->onGetSampledDimensions(sampleSize);
}

getSampledSubsetDimensions()

SkISize SkAndroidCodec::getSampledSubsetDimensions	(	int	sampleSize,
		const SkIRect &	subset
	)		const

Returns the dimensions of the scaled, partial output image, for an input sampleSize and subset.

Parameters

sampleSize	Factor to scale down by.
subset	Must be a valid subset of the original image dimensions and a subset supported by SkAndroidCodec. getSubset() can be used to obtain a subset supported by SkAndroidCodec.

Returns

Size of the scaled partial image. Or zero size if either of the inputs is invalid.

Definition at line 466 of file SkAndroidCodec.cpp.

                                                                                              {
    if (!is_valid_sample_size(sampleSize)) {
        return {0, 0};
    }
 
    // We require that the input subset is a subset that is supported by SkAndroidCodec.
    // We test this by calling getSupportedSubset() and verifying that no modifications
    // are made to the subset.
    SkIRect copySubset = subset;
    if (!this->getSupportedSubset(&copySubset) || copySubset != subset) {
        return {0, 0};
    }
 
    // If the subset is the entire image, for consistency, use getSampledDimensions().
    if (fCodec->dimensions() == subset.size()) {
        return this->getSampledDimensions(sampleSize);
    }
 
    // This should perhaps call a virtual function, but currently both of our subclasses
    // want the same implementation.
    return {get_scaled_dimension(subset.width(), sampleSize),
            get_scaled_dimension(subset.height(), sampleSize)};
}

getSupportedSubset()

bool SkAndroidCodec::getSupportedSubset

(

SkIRect *

desiredSubset

)

const

Return (via desiredSubset) a subset which can decoded from this codec, or false if the input subset is invalid.

Parameters

desiredSubset

in/out parameter As input, a desired subset of the original bounds (as specified by getInfo). As output, 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 the input desiredSubset is valid. desiredSubset may be modified to a subset supported by the codec. false If desiredSubset is invalid (NULL or not fully contained within the image).

Definition at line 458 of file SkAndroidCodec.cpp.

                                                                    {
    if (!desiredSubset || !is_valid_subset(*desiredSubset, fCodec->dimensions())) {
        return false;
    }
 
    return this->onGetSupportedSubset(desiredSubset);
}

MakeFromCodec()

std::unique_ptr< SkAndroidCodec > SkAndroidCodec::MakeFromCodec ( std::unique_ptr< SkCodec >  codec )

static

Pass ownership of an SkCodec to a newly-created SkAndroidCodec.

Definition at line 212 of file SkAndroidCodec.cpp.

                                                                                        {
    if (nullptr == codec) {
        return nullptr;
    }
 
    const SkEncodedImageFormat format = codec->getEncodedFormat();
    if (format == SkEncodedImageFormat::kAVIF) {
        if (SkCodecs::HasDecoder("avif")) {
            // If a dedicated AVIF decoder has been registered, SkAvifCodec can
            // handle scaling internally.
            return std::make_unique<SkAndroidCodecAdapter>(codec.release());
        }
        // This will fallback to SkHeifCodec, which needs sampling.
        return std::make_unique<SkSampledCodec>(codec.release());
    }
 
    switch (format) {
        case SkEncodedImageFormat::kPNG:
        case SkEncodedImageFormat::kICO:
        case SkEncodedImageFormat::kJPEG:
        case SkEncodedImageFormat::kBMP:
        case SkEncodedImageFormat::kWBMP:
        case SkEncodedImageFormat::kHEIF:
            return std::make_unique<SkSampledCodec>(codec.release());
        case SkEncodedImageFormat::kGIF:
        case SkEncodedImageFormat::kWEBP:
        case SkEncodedImageFormat::kDNG:
            return std::make_unique<SkAndroidCodecAdapter>(codec.release());
        case SkEncodedImageFormat::kAVIF: // Handled above
        case SkEncodedImageFormat::kPKM:
        case SkEncodedImageFormat::kKTX:
        case SkEncodedImageFormat::kASTC:
        case SkEncodedImageFormat::kJPEGXL:
            return nullptr;
    }
    SkUNREACHABLE;
}

MakeFromData()

std::unique_ptr< SkAndroidCodec > SkAndroidCodec::MakeFromData ( sk_sp< SkData >  data, SkPngChunkReader *  chunkReader = nullptr  )

static

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

The SkPngChunkReader handles unknown chunks in PNGs. See SkCodec.h for more details.

Definition at line 250 of file SkAndroidCodec.cpp.

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

MakeFromStream()

std::unique_ptr< SkAndroidCodec > SkAndroidCodec::MakeFromStream ( std::unique_ptr< SkStream >  stream, SkPngChunkReader *  chunkReader = nullptr  )

static

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

The SkPngChunkReader handles unknown chunks in PNGs. See SkCodec.h for more details.

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 206 of file SkAndroidCodec.cpp.

                                                                                              {
    auto codec = SkCodec::MakeFromStream(std::move(stream), nullptr, chunkReader);
    return MakeFromCodec(std::move(codec));
}

onGetAndroidPixels()

virtual SkCodec::Result SkAndroidCodec::onGetAndroidPixels ( const SkImageInfo &  info, void *  pixels, size_t  rowBytes, const AndroidOptions &  options  )

protectedpure virtual

Implemented in SkAndroidCodecAdapter, and SkSampledCodec.

onGetSampledDimensions()

virtual SkISize SkAndroidCodec::onGetSampledDimensions ( int  sampleSize ) const

protectedpure virtual

Implemented in SkAndroidCodecAdapter, and SkSampledCodec.

onGetSupportedSubset()

virtual bool SkAndroidCodec::onGetSupportedSubset ( SkIRect *  desiredSubset ) const

protectedpure virtual

Implemented in SkAndroidCodecAdapter, and SkSampledCodec.

---

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

• third_party/skia/include/codec/SkAndroidCodec.h
• third_party/skia/src/codec/SkAndroidCodec.cpp