SkAnimatedImage Class Reference

#include <SkAnimatedImage.h>

Inheritance diagram for SkAnimatedImage:

Public Member Functions
	~SkAnimatedImage () override
void	reset ()
bool	isFinished () const
int	decodeNextFrame ()
sk_sp< SkImage >	getCurrentFrame ()
int	currentFrameDuration ()
void	setRepetitionCount (int count)
int	getRepetitionCount () const
int	getFrameCount () const
Public Member Functions inherited from SkDrawable
void	draw (SkCanvas *, const SkMatrix *=nullptr)
void	draw (SkCanvas *, SkScalar x, SkScalar y)
std::unique_ptr< GpuDrawHandler >	snapGpuDrawHandler (GrBackendApi backendApi, const SkMatrix &matrix, const SkIRect &clipBounds, const SkImageInfo &bufferInfo)
sk_sp< SkPicture >	makePictureSnapshot ()
uint32_t	getGenerationID ()
SkRect	getBounds ()
size_t	approximateBytesUsed ()
void	notifyDrawingChanged ()
SkFlattenable::Type	getFlattenableType () const override
Factory	getFactory () const override
const char *	getTypeName () const override
Public Member Functions inherited from SkFlattenable
	SkFlattenable ()
virtual void	flatten (SkWriteBuffer &) const
sk_sp< SkData >	serialize (const SkSerialProcs *=nullptr) const
size_t	serialize (void *memory, size_t memory_size, const SkSerialProcs *=nullptr) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< SkAnimatedImage >	Make (std::unique_ptr< SkAndroidCodec >, const SkImageInfo &info, SkIRect cropRect, sk_sp< SkPicture > postProcess)
static sk_sp< SkAnimatedImage >	Make (std::unique_ptr< SkAndroidCodec >)
Static Public Member Functions inherited from SkDrawable
static SkFlattenable::Type	GetFlattenableType ()
static sk_sp< SkDrawable >	Deserialize (const void *data, size_t size, const SkDeserialProcs *procs=nullptr)
Static Public Member Functions inherited from SkFlattenable
static Factory	NameToFactory (const char name[])
static const char *	FactoryToName (Factory)
static void	Register (const char name[], Factory)
static sk_sp< SkFlattenable >	Deserialize (Type, const void *data, size_t length, const SkDeserialProcs *procs=nullptr)

Static Public Attributes
static constexpr int	kFinished = -1

Protected Member Functions
SkRect	onGetBounds () override
void	onDraw (SkCanvas *) override
Protected Member Functions inherited from SkDrawable
	SkDrawable ()
virtual size_t	onApproximateBytesUsed ()
virtual std::unique_ptr< GpuDrawHandler >	onSnapGpuDrawHandler (GrBackendApi, const SkMatrix &, const SkIRect &, const SkImageInfo &)
virtual std::unique_ptr< GpuDrawHandler >	onSnapGpuDrawHandler (GrBackendApi, const SkMatrix &)
virtual sk_sp< SkPicture >	onMakePictureSnapshot ()

Additional Inherited Members
Public Types inherited from SkFlattenable
enum	Type {   kSkColorFilter_Type , kSkBlender_Type , kSkDrawable_Type , kSkDrawLooper_Type ,   kSkImageFilter_Type , kSkMaskFilter_Type , kSkPathEffect_Type , kSkShader_Type }
typedef sk_sp< SkFlattenable >(*	Factory) (SkReadBuffer &)

Detailed Description

Thread unsafe drawable for drawing animated images (e.g. GIF).

Definition at line 24 of file SkAnimatedImage.h.

Constructor & Destructor Documentation

~SkAnimatedImage()

SkAnimatedImage::~SkAnimatedImage ( )

override

Definition at line 106 of file SkAnimatedImage.cpp.

{ }

Member Function Documentation

currentFrameDuration()

int SkAnimatedImage::currentFrameDuration ( )

inline

How long to display the current frame.

Useful for the first frame, for which decodeNextFrame is called internally.

Definition at line 86 of file SkAnimatedImage.h.

                               {
        return fCurrentFrameDuration;
    }

decodeNextFrame()

int SkAnimatedImage::decodeNextFrame

(

)

Decode the next frame.

If the animation is on the last frame or has hit an error, returns kFinished.

Definition at line 190 of file SkAnimatedImage.cpp.

                                     {
    if (fFinished) {
        return kFinished;
    }
 
    bool animationEnded = false;
    const int frameToDecode = this->computeNextFrame(fDisplayFrame.fIndex, &animationEnded);
 
    SkCodec::FrameInfo frameInfo;
    if (fCodec->codec()->getFrameInfo(frameToDecode, &frameInfo)) {
        if (!frameInfo.fFullyReceived) {
            SkCodecPrintf("Frame %i not fully received\n", frameToDecode);
            return this->finish();
        }
 
        fCurrentFrameDuration = frameInfo.fDuration;
    } else {
        animationEnded = true;
        if (0 == frameToDecode) {
            // Static image. This is okay.
            frameInfo.fRequiredFrame = SkCodec::kNoFrame;
            frameInfo.fAlphaType = fCodec->getInfo().alphaType();
            frameInfo.fDisposalMethod = SkCodecAnimation::DisposalMethod::kKeep;
            // These fields won't be read.
            frameInfo.fDuration = INT_MAX;
            frameInfo.fFullyReceived = true;
            fCurrentFrameDuration = kFinished;
        } else {
            SkCodecPrintf("Error getting frameInfo for frame %i\n",
                          frameToDecode);
            return this->finish();
        }
    }
 
    if (frameToDecode == fDisplayFrame.fIndex) {
        if (animationEnded) {
            return this->finish();
        }
        return fCurrentFrameDuration;
    }
 
    for (Frame* frame : { &fRestoreFrame, &fDecodingFrame }) {
        if (frameToDecode == frame->fIndex) {
            using std::swap;
            swap(fDisplayFrame, *frame);
            if (animationEnded) {
                return this->finish();
            }
            return fCurrentFrameDuration;
        }
    }
 
    // The following code makes an effort to avoid overwriting a frame that will
    // be used again. If frame |i| is_restore_previous, frame |i+1| will not
    // depend on frame |i|, so do not overwrite frame |i-1|, which may be needed
    // for frame |i+1|.
    // We could be even smarter about which frames to save by looking at the
    // entire dependency chain.
    SkAndroidCodec::AndroidOptions options;
    options.fSampleSize = fSampleSize;
    options.fFrameIndex = frameToDecode;
    if (frameInfo.fRequiredFrame == SkCodec::kNoFrame) {
        if (is_restore_previous(frameInfo.fDisposalMethod)) {
            // frameToDecode will be discarded immediately after drawing, so
            // do not overwrite a frame which could possibly be used in the
            // future.
            if (fDecodingFrame.fIndex != SkCodec::kNoFrame &&
                    !is_restore_previous(fDecodingFrame.fDisposalMethod)) {
                using std::swap;
                swap(fDecodingFrame, fRestoreFrame);
            }
        }
    } else {
        auto validPriorFrame = [&frameInfo, &frameToDecode](const Frame& frame) {
            if (SkCodec::kNoFrame == frame.fIndex ||
                    is_restore_previous(frame.fDisposalMethod)) {
                return false;
            }
 
            return frame.fIndex >= frameInfo.fRequiredFrame && frame.fIndex < frameToDecode;
        };
        if (validPriorFrame(fDecodingFrame)) {
            if (is_restore_previous(frameInfo.fDisposalMethod)) {
                // fDecodingFrame is a good frame to use for this one, but we
                // don't want to overwrite it.
                fDecodingFrame.copyTo(&fRestoreFrame);
            }
            options.fPriorFrame = fDecodingFrame.fIndex;
        } else if (validPriorFrame(fDisplayFrame)) {
            if (!fDisplayFrame.copyTo(&fDecodingFrame)) {
                SkCodecPrintf("Failed to allocate pixels for frame\n");
                return this->finish();
            }
            options.fPriorFrame = fDecodingFrame.fIndex;
        } else if (validPriorFrame(fRestoreFrame)) {
            if (!is_restore_previous(frameInfo.fDisposalMethod)) {
                using std::swap;
                swap(fDecodingFrame, fRestoreFrame);
            } else if (!fRestoreFrame.copyTo(&fDecodingFrame)) {
                SkCodecPrintf("Failed to restore frame\n");
                return this->finish();
            }
            options.fPriorFrame = fDecodingFrame.fIndex;
        }
    }
 
    auto alphaType = kOpaque_SkAlphaType == frameInfo.fAlphaType ?
                     kOpaque_SkAlphaType : kPremul_SkAlphaType;
    auto info = fDecodeInfo.makeAlphaType(alphaType);
    SkBitmap* dst = &fDecodingFrame.fBitmap;
    if (!fDecodingFrame.init(info, Frame::OnInit::kRestoreIfNecessary)) {
        return this->finish();
    }
 
    auto result = fCodec->getAndroidPixels(dst->info(), dst->getPixels(), dst->rowBytes(),
                                           &options);
    if (result != SkCodec::kSuccess) {
        SkCodecPrintf("%s, frame %i of %i\n", SkCodec::ResultToString(result),
                      frameToDecode, fFrameCount);
        return this->finish();
    }
 
    fDecodingFrame.fIndex = frameToDecode;
    fDecodingFrame.fDisposalMethod = frameInfo.fDisposalMethod;
 
    using std::swap;
    swap(fDecodingFrame, fDisplayFrame);
    fDisplayFrame.fBitmap.notifyPixelsChanged();
 
    if (animationEnded) {
        return this->finish();
    } else if (fCodec->getEncodedFormat() == SkEncodedImageFormat::kHEIF) {
        // HEIF doesn't know the frame duration until after decoding. Update to
        // the correct value. Note that earlier returns in this method either
        // return kFinished, or fCurrentFrameDuration. If they return the
        // latter, it is a frame that was previously decoded, so it has the
        // updated value.
        if (fCodec->codec()->getFrameInfo(frameToDecode, &frameInfo)) {
            fCurrentFrameDuration = frameInfo.fDuration;
        } else {
            SkCodecPrintf("Failed to getFrameInfo on second attempt (HEIF)");
        }
    }
    return fCurrentFrameDuration;
}

getCurrentFrame()

sk_sp< SkImage > SkAnimatedImage::getCurrentFrame

(

)

Returns the current frame as an SkImage. The SkImage will not change after it has been returned. If there is no current frame, nullptr will be returned.

Definition at line 372 of file SkAnimatedImage.cpp.

                                                {
    if (this->simple()) return this->getCurrentFrameSimple();
 
    auto imageInfo = fDisplayFrame.fBitmap.info().makeDimensions(fCropRect.size());
    if (fPostProcess) {
        // Defensively use premul in case the post process adds alpha.
        imageInfo = imageInfo.makeAlphaType(kPremul_SkAlphaType);
    }
 
    SkBitmap dst;
    if (!dst.tryAllocPixels(imageInfo)) {
        return nullptr;
    }
 
    SkCanvas canvas(dst);
    this->draw(&canvas);
    return SkMakeImageFromRasterBitmap(dst, kNever_SkCopyPixelsMode);
}

getFrameCount()

int SkAnimatedImage::getFrameCount ( ) const

inline

Return the total number of frames in the animation.

Definition at line 111 of file SkAnimatedImage.h.

{ return fFrameCount; }

getRepetitionCount()

int SkAnimatedImage::getRepetitionCount ( ) const

inline

Return the currently set repetition count.

Definition at line 104 of file SkAnimatedImage.h.

                                   {
        return fRepetitionCount;
    }

isFinished()

bool SkAnimatedImage::isFinished ( ) const

inline

Whether the animation completed.

Returns true after all repetitions are complete, or an error stops the animation. Gets reset to false if the animation is restarted.

Definition at line 57 of file SkAnimatedImage.h.

{ return fFinished; }

Make() [1/2]

sk_sp< SkAnimatedImage > SkAnimatedImage::Make ( std::unique_ptr< SkAndroidCodec >  codec )

static

Simpler version that uses the default size, no cropping, and no postProcess.

Definition at line 43 of file SkAnimatedImage.cpp.

                                                                                {
    if (!codec) {
        return nullptr;
    }
 
    auto decodeInfo = codec->getInfo();
    const auto origin = codec->codec()->getOrigin();
    if (SkEncodedOriginSwapsWidthHeight(origin)) {
        decodeInfo = decodeInfo.makeWH(decodeInfo.height(), decodeInfo.width());
    }
    const auto cropRect = SkIRect::MakeSize(decodeInfo.dimensions());
    return Make(std::move(codec), decodeInfo, cropRect, nullptr);
}

Make() [2/2]

sk_sp< SkAnimatedImage > SkAnimatedImage::Make ( std::unique_ptr< SkAndroidCodec >  codec, const SkImageInfo &  info, SkIRect  cropRect, sk_sp< SkPicture >  postProcess  )

static

Create an SkAnimatedImage from the SkAndroidCodec.

Returns null on failure to allocate pixels. On success, this will decode the first frame.

Parameters

info	Width and height may require scaling.
cropRect	Rectangle to crop to after scaling.
postProcess	Picture to apply after scaling and cropping.

Definition at line 23 of file SkAnimatedImage.cpp.

                                                                                          {
    if (!codec) {
        return nullptr;
    }
 
    if (!requestedInfo.bounds().contains(cropRect)) {
        return nullptr;
    }
 
    auto image = sk_sp<SkAnimatedImage>(new SkAnimatedImage(std::move(codec), requestedInfo,
                cropRect, std::move(postProcess)));
    if (!image->fDisplayFrame.fBitmap.getPixels()) {
        // tryAllocPixels failed.
        return nullptr;
    }
 
    return image;
}

onDraw()

void SkAnimatedImage::onDraw ( SkCanvas *  canvas )

overrideprotectedvirtual

Implements SkDrawable.

Definition at line 336 of file SkAnimatedImage.cpp.

                                             {
    auto image = this->getCurrentFrameSimple();
 
    if (this->simple()) {
        canvas->drawImage(image, 0, 0);
        return;
    }
 
    SkRect bounds = this->getBounds();
    if (fPostProcess) {
        canvas->saveLayer(&bounds, nullptr);
    }
    canvas->clipRect(bounds);
    {
        SkAutoCanvasRestore acr(canvas, fPostProcess != nullptr);
        canvas->concat(fMatrix);
        canvas->drawImage(image, 0, 0, SkSamplingOptions(SkFilterMode::kLinear), nullptr);
    }
    if (fPostProcess) {
        canvas->drawPicture(fPostProcess);
        canvas->restore();
    }
}

onGetBounds()

SkRect SkAnimatedImage::onGetBounds ( )

overrideprotectedvirtual

Implements SkDrawable.

Definition at line 108 of file SkAnimatedImage.cpp.

                                    {
    return SkRect::MakeIWH(fCropRect.width(), fCropRect.height());
}

reset()

void SkAnimatedImage::reset

(

)

Reset the animation to the beginning.

Definition at line 153 of file SkAnimatedImage.cpp.

                            {
    fFinished = false;
    fRepetitionsCompleted = 0;
    if (fDisplayFrame.fIndex != 0) {
        fDisplayFrame.fIndex = SkCodec::kNoFrame;
        this->decodeNextFrame();
    }
}

setRepetitionCount()

void SkAnimatedImage::setRepetitionCount

(

int

count

)

Change the repetition count.

By default, the image will repeat the number of times indicated in the encoded data.

Use SkCodec::kRepetitionCountInfinite for infinite, and 0 to show all frames once and then stop.

Definition at line 360 of file SkAnimatedImage.cpp.

                                                     {
    fRepetitionCount = newCount;
}

Member Data Documentation

kFinished

constexpr int SkAnimatedImage::kFinished = -1

staticconstexpr

Returned by decodeNextFrame and currentFrameDuration if the animation is not running.

Definition at line 63 of file SkAnimatedImage.h.

---

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

• third_party/skia/include/android/SkAnimatedImage.h
• third_party/skia/src/android/SkAnimatedImage.cpp