/*

 * Copyright 2018 Google Inc.

 *

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#ifndef SkAnimatedImage_DEFINED

#define SkAnimatedImage_DEFINED

#include "include/codec/SkCodecAnimation.h"

#include "include/core/SkBitmap.h"

#include "include/core/SkDrawable.h"

#include "include/core/SkMatrix.h"

#include "include/core/SkRect.h"

class SkAndroidCodec;

class SkImage;

class SkPicture;

/**

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

 */

class SK_API SkAnimatedImage : public SkDrawable {

public:

    /**

     *  Create an SkAnimatedImage from the SkAndroidCodec.

     *

     *  Returns null on failure to allocate pixels. On success, this will

     *  decode the first frame.

     *

     *  @param info Width and height may require scaling.

     *  @param cropRect Rectangle to crop to after scaling.

     *  @param postProcess Picture to apply after scaling and cropping.

     */

    static sk_sp<SkAnimatedImage> Make(std::unique_ptr<SkAndroidCodec>,

            const SkImageInfo& info, SkIRect cropRect, sk_sp<SkPicture> postProcess);

    /**

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

     */

    static sk_sp<SkAnimatedImage> Make(std::unique_ptr<SkAndroidCodec>);

    ~SkAnimatedImage() override;

    /**

     *  Reset the animation to the beginning.

     */

    void reset();

    /**

     *  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.

     */

    bool isFinished() const { return fFinished; }

    /**

     * Returned by decodeNextFrame and currentFrameDuration if the animation

     * is not running.

     */

    static constexpr int kFinished = -1;

    /**

     *  Decode the next frame.

     *

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

     *  kFinished.

     */

    int decodeNextFrame();

    /**

     *  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.

     */

    sk_sp<SkImage> getCurrentFrame();

    /**

     *  How long to display the current frame.

     *

     *  Useful for the first frame, for which decodeNextFrame is called

     *  internally.

     */

    int currentFrameDuration() {

        return fCurrentFrameDuration;

    }

    /**

     *  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.

     */

    void setRepetitionCount(int count);

    /**

     *  Return the currently set repetition count.

     */

    int getRepetitionCount() const {

        return fRepetitionCount;

    }

    /**

     *  Return the total number of frames in the animation.

     */

    int getFrameCount() const { return fFrameCount; }

protected:

    SkRect onGetBounds() override;

    void onDraw(SkCanvas*) override;

private:

    struct Frame {

        SkBitmap fBitmap;

        int      fIndex;

        SkCodecAnimation::DisposalMethod fDisposalMethod;

        // init() may have to create a new SkPixelRef, if the

        // current one is already in use by another owner (e.g.

        // an SkPicture). This determines whether to copy the

        // existing one to the new one.

        enum class OnInit {

            // Restore the image from the old SkPixelRef to the

            // new one.

            kRestoreIfNecessary,

            // No need to restore.

            kNoRestore,

        };

        Frame();

        bool init(const SkImageInfo& info, OnInit);

        bool copyTo(Frame*) const;

    };

    std::unique_ptr<SkAndroidCodec> fCodec;

          SkImageInfo               fDecodeInfo;

    const SkIRect                   fCropRect;

    const sk_sp<SkPicture>          fPostProcess;

    const int                       fFrameCount;

    SkMatrix                        fMatrix;

    int                             fSampleSize;

    bool                            fFinished;

    int                             fCurrentFrameDuration;

    Frame                           fDisplayFrame;

    Frame                           fDecodingFrame;

    Frame                           fRestoreFrame;

    int                             fRepetitionCount;

    int                             fRepetitionsCompleted;

    SkAnimatedImage(std::unique_ptr<SkAndroidCodec>, const SkImageInfo& requestedInfo,

            SkIRect cropRect, sk_sp<SkPicture> postProcess);

    int computeNextFrame(int current, bool* animationEnded);

    double finish();

    /**

     *  True if there is no crop, orientation, or post decoding scaling.

     */

    bool simple() const { return fMatrix.isIdentity() && !fPostProcess

                                 && fCropRect == fDecodeInfo.bounds(); }

    /**

     *  Returns the current frame as an SkImage.

     *

     *  Like getCurrentFrame, but only returns the raw data from the internal SkBitmap. (i.e. no

     *  scaling, orientation-correction or cropping.) If simple(), this is the final output.

     */

    sk_sp<SkImage> getCurrentFrameSimple();

    using INHERITED = SkDrawable;

};

#endif // SkAnimatedImage_DEFINED