SkSampledCodec Class Reference

#include <SkSampledCodec.h>

Inheritance diagram for SkSampledCodec:

Public Member Functions
	SkSampledCodec (SkCodec *)
	~SkSampledCodec () override
Public Member Functions inherited from SkAndroidCodec
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)

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

Additional Inherited Members
Public Types inherited from SkAndroidCodec
enum class	ExifOrientationBehavior { kIgnore , kRespect }
Static Public Member Functions inherited from SkAndroidCodec
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)

Detailed Description

This class implements the functionality of SkAndroidCodec. Scaling will be provided by sampling if it cannot be provided by fCodec.

Definition at line 23 of file SkSampledCodec.h.

Constructor & Destructor Documentation

SkSampledCodec()

SkSampledCodec::SkSampledCodec ( SkCodec *  codec )

explicit

Definition at line 20 of file SkSampledCodec.cpp.

    : INHERITED(codec)
{}

~SkSampledCodec()

SkSampledCodec::~SkSampledCodec ( )

inlineoverride

Definition at line 27 of file SkSampledCodec.h.

{}

Member Function Documentation

onGetAndroidPixels()

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

overrideprotectedvirtual

Implements SkAndroidCodec.

Definition at line 78 of file SkSampledCodec.cpp.

                                                        {
    const SkIRect* subset = options.fSubset;
    if (!subset || subset->size() == this->codec()->dimensions()) {
        if (this->codec()->dimensionsSupported(info.dimensions())) {
            return this->codec()->getPixels(info, pixels, rowBytes, &options);
        }
 
        // If the native codec does not support the requested scale, scale by sampling.
        return this->sampledDecode(info, pixels, rowBytes, options);
    }
 
    // We are performing a subset decode.
    int sampleSize = options.fSampleSize;
    SkISize scaledSize = this->getSampledDimensions(sampleSize);
    if (!this->codec()->dimensionsSupported(scaledSize)) {
        // If the native codec does not support the requested scale, scale by sampling.
        return this->sampledDecode(info, pixels, rowBytes, options);
    }
 
    // Calculate the scaled subset bounds.
    int scaledSubsetX = subset->x() / sampleSize;
    int scaledSubsetY = subset->y() / sampleSize;
    int scaledSubsetWidth = info.width();
    int scaledSubsetHeight = info.height();
 
    const SkImageInfo scaledInfo = info.makeDimensions(scaledSize);
 
    // Copy so we can use a different fSubset.
    AndroidOptions subsetOptions = options;
    {
        // Although startScanlineDecode expects the bottom and top to match the
        // SkImageInfo, startIncrementalDecode uses them to determine which rows to
        // decode.
        SkIRect incrementalSubset = SkIRect::MakeXYWH(scaledSubsetX, scaledSubsetY,
                                                      scaledSubsetWidth, scaledSubsetHeight);
        subsetOptions.fSubset = &incrementalSubset;
        const SkCodec::Result startResult = this->codec()->startIncrementalDecode(
                scaledInfo, pixels, rowBytes, &subsetOptions);
        if (SkCodec::kSuccess == startResult) {
            int rowsDecoded = 0;
            const SkCodec::Result incResult = this->codec()->incrementalDecode(&rowsDecoded);
            if (incResult == SkCodec::kSuccess) {
                return SkCodec::kSuccess;
            }
            SkASSERT(incResult == SkCodec::kIncompleteInput || incResult == SkCodec::kErrorInInput);
 
            // FIXME: Can zero initialized be read from SkCodec::fOptions?
            this->codec()->fillIncompleteImage(scaledInfo, pixels, rowBytes,
                    options.fZeroInitialized, scaledSubsetHeight, rowsDecoded);
            return incResult;
        } else if (startResult != SkCodec::kUnimplemented) {
            return startResult;
        }
        // Otherwise fall down to use the old scanline decoder.
        // subsetOptions.fSubset will be reset below, so it will not continue to
        // point to the object that is no longer on the stack.
    }
 
    // Start the scanline decode.
    SkIRect scanlineSubset = SkIRect::MakeXYWH(scaledSubsetX, 0, scaledSubsetWidth,
            scaledSize.height());
    subsetOptions.fSubset = &scanlineSubset;
 
    SkCodec::Result result = this->codec()->startScanlineDecode(scaledInfo,
            &subsetOptions);
    if (SkCodec::kSuccess != result) {
        return result;
    }
 
    // At this point, we are only concerned with subsetting.  Either no scale was
    // requested, or the this->codec() is handling the scale.
    // Note that subsetting is only supported for kTopDown, so this code will not be
    // reached for other orders.
    SkASSERT(this->codec()->getScanlineOrder() == SkCodec::kTopDown_SkScanlineOrder);
    if (!this->codec()->skipScanlines(scaledSubsetY)) {
        this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                scaledSubsetHeight, 0);
        return SkCodec::kIncompleteInput;
    }
 
    int decodedLines = this->codec()->getScanlines(pixels, scaledSubsetHeight, rowBytes);
    if (decodedLines != scaledSubsetHeight) {
        return SkCodec::kIncompleteInput;
    }
    return SkCodec::kSuccess;
}

onGetSampledDimensions()

SkISize SkSampledCodec::onGetSampledDimensions ( int  sampleSize ) const

overrideprotectedvirtual

Implements SkAndroidCodec.

Definition at line 72 of file SkSampledCodec.cpp.

                                                                   {
    const SkISize size = this->accountForNativeScaling(&sampleSize);
    return SkISize::Make(get_scaled_dimension(size.width(), sampleSize),
                         get_scaled_dimension(size.height(), sampleSize));
}

onGetSupportedSubset()

bool SkSampledCodec::onGetSupportedSubset ( SkIRect *  desiredSubset ) const

inlineoverrideprotectedvirtual

Implements SkAndroidCodec.

Definition at line 33 of file SkSampledCodec.h.

{ return true; }

---

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

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