1 /* 2 * Copyright 2017 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkFrameHolder_DEFINED 9 #define SkFrameHolder_DEFINED 10 11 #include "SkTypes.h" 12 #include "SkCodecAnimation.h" 13 #include "SkCodecAnimationPriv.h" 14 #include "SkRect.h" 15 16 /** 17 * Base class for a single frame of an animated image. 18 * 19 * Separate from SkCodec::FrameInfo, which is a pared down 20 * interface that only contains the info the client needs. 21 */ 22 class SkFrame : public SkNoncopyable { 23 public: SkFrame(int id)24 SkFrame(int id) 25 : fId(id) 26 , fHasAlpha(false) 27 , fRequiredFrame(kUninitialized) 28 , fDisposalMethod(SkCodecAnimation::DisposalMethod::kKeep) 29 , fDuration(0) 30 , fBlend(SkCodecAnimation::Blend::kPriorFrame) 31 { 32 fRect.setEmpty(); 33 } 34 ~SkFrame()35 virtual ~SkFrame() {} 36 37 /** 38 * An explicit move constructor, as 39 * https://en.cppreference.com/w/cpp/language/move_constructor says that 40 * there is no implicit move constructor if there are user-declared 41 * destructors, and we have one, immediately above. 42 * 43 * Without a move constructor, it is harder to use an SkFrame, or an 44 * SkFrame subclass, inside a std::vector. 45 */ 46 SkFrame(SkFrame&&) = default; 47 48 /** 49 * 0-based index of the frame in the image sequence. 50 */ frameId()51 int frameId() const { return fId; } 52 53 /** 54 * How this frame reports its alpha. 55 * 56 * This only considers the rectangle of this frame, and 57 * considers it to have alpha even if it is opaque once 58 * blended with the frame behind it. 59 */ reportedAlpha()60 SkEncodedInfo::Alpha reportedAlpha() const { 61 return this->onReportedAlpha(); 62 } 63 64 /** 65 * Cached value representing whether the frame has alpha, 66 * after compositing with the prior frame. 67 */ hasAlpha()68 bool hasAlpha() const { return fHasAlpha; } 69 70 /** 71 * Cache whether the finished frame has alpha. 72 */ setHasAlpha(bool alpha)73 void setHasAlpha(bool alpha) { fHasAlpha = alpha; } 74 75 /** 76 * Whether enough of the frame has been read to determine 77 * fRequiredFrame and fHasAlpha. 78 */ reachedStartOfData()79 bool reachedStartOfData() const { return fRequiredFrame != kUninitialized; } 80 81 /** 82 * The frame this one depends on. 83 * 84 * Must not be called until fRequiredFrame has been set properly. 85 */ getRequiredFrame()86 int getRequiredFrame() const { 87 SkASSERT(this->reachedStartOfData()); 88 return fRequiredFrame; 89 } 90 91 /** 92 * Set the frame that this frame depends on. 93 */ setRequiredFrame(int req)94 void setRequiredFrame(int req) { fRequiredFrame = req; } 95 96 /** 97 * Set the rectangle that is updated by this frame. 98 */ setXYWH(int x,int y,int width,int height)99 void setXYWH(int x, int y, int width, int height) { 100 fRect.setXYWH(x, y, width, height); 101 } 102 103 /** 104 * The rectangle that is updated by this frame. 105 */ frameRect()106 SkIRect frameRect() const { return fRect; } 107 xOffset()108 int xOffset() const { return fRect.x(); } yOffset()109 int yOffset() const { return fRect.y(); } width()110 int width() const { return fRect.width(); } height()111 int height() const { return fRect.height(); } 112 getDisposalMethod()113 SkCodecAnimation::DisposalMethod getDisposalMethod() const { 114 return fDisposalMethod; 115 } 116 setDisposalMethod(SkCodecAnimation::DisposalMethod disposalMethod)117 void setDisposalMethod(SkCodecAnimation::DisposalMethod disposalMethod) { 118 fDisposalMethod = disposalMethod; 119 } 120 121 /** 122 * Set the duration (in ms) to show this frame. 123 */ setDuration(int duration)124 void setDuration(int duration) { 125 fDuration = duration; 126 } 127 128 /** 129 * Duration in ms to show this frame. 130 */ getDuration()131 int getDuration() const { 132 return fDuration; 133 } 134 setBlend(SkCodecAnimation::Blend blend)135 void setBlend(SkCodecAnimation::Blend blend) { 136 fBlend = blend; 137 } 138 getBlend()139 SkCodecAnimation::Blend getBlend() const { 140 return fBlend; 141 } 142 143 protected: 144 virtual SkEncodedInfo::Alpha onReportedAlpha() const = 0; 145 146 private: 147 static constexpr int kUninitialized = -2; 148 149 const int fId; 150 bool fHasAlpha; 151 int fRequiredFrame; 152 SkIRect fRect; 153 SkCodecAnimation::DisposalMethod fDisposalMethod; 154 int fDuration; 155 SkCodecAnimation::Blend fBlend; 156 }; 157 158 /** 159 * Base class for an object which holds the SkFrames of an 160 * image sequence. 161 */ 162 class SkFrameHolder : public SkNoncopyable { 163 public: SkFrameHolder()164 SkFrameHolder() 165 : fScreenWidth(0) 166 , fScreenHeight(0) 167 {} 168 ~SkFrameHolder()169 virtual ~SkFrameHolder() {} 170 171 /** 172 * Size of the image. Each frame will be contained in 173 * these dimensions (possibly after clipping). 174 */ screenWidth()175 int screenWidth() const { return fScreenWidth; } screenHeight()176 int screenHeight() const { return fScreenHeight; } 177 178 /** 179 * Compute the opacity and required frame, based on 180 * the frame's reportedAlpha and how it blends 181 * with prior frames. 182 */ 183 void setAlphaAndRequiredFrame(SkFrame*); 184 185 /** 186 * Return the frame with frameId i. 187 */ getFrame(int i)188 const SkFrame* getFrame(int i) const { 189 return this->onGetFrame(i); 190 } 191 192 protected: 193 int fScreenWidth; 194 int fScreenHeight; 195 196 virtual const SkFrame* onGetFrame(int i) const = 0; 197 }; 198 199 #endif // SkFrameHolder_DEFINED 200