summaryrefslogtreecommitdiffstats
path: root/image/FrameAnimator.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--image/FrameAnimator.cpp519
1 files changed, 519 insertions, 0 deletions
diff --git a/image/FrameAnimator.cpp b/image/FrameAnimator.cpp
new file mode 100644
index 0000000000..f21877d81a
--- /dev/null
+++ b/image/FrameAnimator.cpp
@@ -0,0 +1,519 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "FrameAnimator.h"
+
+#include <utility>
+
+#include "LookupResult.h"
+#include "RasterImage.h"
+#include "imgIContainer.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/StaticPrefs_image.h"
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace image {
+
+///////////////////////////////////////////////////////////////////////////////
+// AnimationState implementation.
+///////////////////////////////////////////////////////////////////////////////
+
+const gfx::IntRect AnimationState::UpdateState(
+ RasterImage* aImage, const gfx::IntSize& aSize,
+ bool aAllowInvalidation /* = true */) {
+ LookupResult result = SurfaceCache::Lookup(
+ ImageKey(aImage),
+ RasterSurfaceKey(aSize, DefaultSurfaceFlags(), PlaybackType::eAnimated),
+ /* aMarkUsed = */ false);
+
+ return UpdateStateInternal(result, aSize, aAllowInvalidation);
+}
+
+const gfx::IntRect AnimationState::UpdateStateInternal(
+ LookupResult& aResult, const gfx::IntSize& aSize,
+ bool aAllowInvalidation /* = true */) {
+ // Update mDiscarded and mIsCurrentlyDecoded.
+ if (aResult.Type() == MatchType::NOT_FOUND) {
+ // no frames, we've either been discarded, or never been decoded before.
+ mDiscarded = mHasBeenDecoded;
+ mIsCurrentlyDecoded = false;
+ } else if (aResult.Type() == MatchType::PENDING) {
+ // no frames yet, but a decoder is or will be working on it.
+ mDiscarded = false;
+ mIsCurrentlyDecoded = false;
+ mHasRequestedDecode = true;
+ } else {
+ MOZ_ASSERT(aResult.Type() == MatchType::EXACT);
+ mDiscarded = false;
+ mHasRequestedDecode = true;
+
+ // If we can seek to the current animation frame we consider it decoded.
+ // Animated images are never fully decoded unless very short.
+ // Note that we use GetFrame instead of Seek here. The difference is that
+ // Seek eventually calls AnimationFrameBuffer::Get with aForDisplay == true,
+ // whereas GetFrame calls AnimationFrameBuffer::Get with aForDisplay ==
+ // false. The aForDisplay can change whether those functions succeed or not
+ // (only for the first frame). Since this is not for display we want to pass
+ // aForDisplay == false, but also for consistency with
+ // RequestRefresh/AdvanceFrame, because we want our state to be in sync with
+ // those functions. The user of Seek (GetCompositedFrame) doesn't need to be
+ // in sync with our state.
+ RefPtr<imgFrame> currentFrame =
+ bool(aResult.Surface())
+ ? aResult.Surface().GetFrame(mCurrentAnimationFrameIndex)
+ : nullptr;
+ mIsCurrentlyDecoded = !!currentFrame;
+ }
+
+ gfx::IntRect ret;
+
+ if (aAllowInvalidation) {
+ // Update the value of mCompositedFrameInvalid.
+ if (mIsCurrentlyDecoded) {
+ // It is safe to clear mCompositedFrameInvalid safe to do for images that
+ // are fully decoded but aren't finished animating because before we paint
+ // the refresh driver will call into us to advance to the correct frame,
+ // and that will succeed because we have all the frames.
+ if (mCompositedFrameInvalid) {
+ // Invalidate if we are marking the composited frame valid.
+ ret.SizeTo(aSize);
+ }
+ mCompositedFrameInvalid = false;
+ } else {
+ if (mHasRequestedDecode) {
+ MOZ_ASSERT(StaticPrefs::image_mem_animated_discardable_AtStartup());
+ mCompositedFrameInvalid = true;
+ }
+ }
+ // Otherwise don't change the value of mCompositedFrameInvalid, it will be
+ // updated by RequestRefresh.
+ }
+
+ return ret;
+}
+
+void AnimationState::NotifyDecodeComplete() { mHasBeenDecoded = true; }
+
+void AnimationState::ResetAnimation() { mCurrentAnimationFrameIndex = 0; }
+
+void AnimationState::SetAnimationMode(uint16_t aAnimationMode) {
+ mAnimationMode = aAnimationMode;
+}
+
+void AnimationState::UpdateKnownFrameCount(uint32_t aFrameCount) {
+ if (aFrameCount <= mFrameCount) {
+ // Nothing to do. Since we can redecode animated images, we may see the same
+ // sequence of updates replayed again, so seeing a smaller frame count than
+ // what we already know about doesn't indicate an error.
+ return;
+ }
+
+ MOZ_ASSERT(!mHasBeenDecoded, "Adding new frames after decoding is finished?");
+ MOZ_ASSERT(aFrameCount <= mFrameCount + 1, "Skipped a frame?");
+
+ mFrameCount = aFrameCount;
+}
+
+Maybe<uint32_t> AnimationState::FrameCount() const {
+ return mHasBeenDecoded ? Some(mFrameCount) : Nothing();
+}
+
+void AnimationState::SetFirstFrameRefreshArea(const IntRect& aRefreshArea) {
+ mFirstFrameRefreshArea = aRefreshArea;
+}
+
+void AnimationState::InitAnimationFrameTimeIfNecessary() {
+ if (mCurrentAnimationFrameTime.IsNull()) {
+ mCurrentAnimationFrameTime = TimeStamp::Now();
+ }
+}
+
+void AnimationState::SetAnimationFrameTime(const TimeStamp& aTime) {
+ mCurrentAnimationFrameTime = aTime;
+}
+
+bool AnimationState::MaybeAdvanceAnimationFrameTime(const TimeStamp& aTime) {
+ if (!StaticPrefs::image_animated_resume_from_last_displayed() ||
+ mCurrentAnimationFrameTime >= aTime) {
+ return false;
+ }
+
+ // We are configured to stop an animation when it is out of view, and restart
+ // it from the same point when it comes back into view. The same applies if it
+ // was discarded while out of view.
+ mCurrentAnimationFrameTime = aTime;
+ return true;
+}
+
+uint32_t AnimationState::GetCurrentAnimationFrameIndex() const {
+ return mCurrentAnimationFrameIndex;
+}
+
+FrameTimeout AnimationState::LoopLength() const {
+ // If we don't know the loop length yet, we have to treat it as infinite.
+ if (!mLoopLength) {
+ return FrameTimeout::Forever();
+ }
+
+ MOZ_ASSERT(mHasBeenDecoded,
+ "We know the loop length but decoding isn't done?");
+
+ // If we're not looping, a single loop time has no meaning.
+ if (mAnimationMode != imgIContainer::kNormalAnimMode) {
+ return FrameTimeout::Forever();
+ }
+
+ return *mLoopLength;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// FrameAnimator implementation.
+///////////////////////////////////////////////////////////////////////////////
+
+TimeStamp FrameAnimator::GetCurrentImgFrameEndTime(
+ AnimationState& aState, FrameTimeout aCurrentTimeout) const {
+ if (aCurrentTimeout == FrameTimeout::Forever()) {
+ // We need to return a sentinel value in this case, because our logic
+ // doesn't work correctly if we have an infinitely long timeout. We use one
+ // year in the future as the sentinel because it works with the loop in
+ // RequestRefresh() below.
+ // XXX(seth): It'd be preferable to make our logic work correctly with
+ // infinitely long timeouts.
+ return TimeStamp::NowLoRes() + TimeDuration::FromMilliseconds(31536000.0);
+ }
+
+ TimeDuration durationOfTimeout =
+ TimeDuration::FromMilliseconds(double(aCurrentTimeout.AsMilliseconds()));
+ return aState.mCurrentAnimationFrameTime + durationOfTimeout;
+}
+
+RefreshResult FrameAnimator::AdvanceFrame(AnimationState& aState,
+ DrawableSurface& aFrames,
+ RefPtr<imgFrame>& aCurrentFrame,
+ TimeStamp aTime) {
+ AUTO_PROFILER_LABEL("FrameAnimator::AdvanceFrame", GRAPHICS);
+
+ RefreshResult ret;
+
+ // Determine what the next frame is, taking into account looping.
+ uint32_t currentFrameIndex = aState.mCurrentAnimationFrameIndex;
+ uint32_t nextFrameIndex = currentFrameIndex + 1;
+
+ // Check if we're at the end of the loop. (FrameCount() returns Nothing() if
+ // we don't know the total count yet.)
+ if (aState.FrameCount() == Some(nextFrameIndex)) {
+ // If we are not looping forever, initialize the loop counter
+ if (aState.mLoopRemainingCount < 0 && aState.LoopCount() >= 0) {
+ aState.mLoopRemainingCount = aState.LoopCount();
+ }
+
+ // If animation mode is "loop once", or we're at end of loop counter,
+ // it's time to stop animating.
+ if (aState.mAnimationMode == imgIContainer::kLoopOnceAnimMode ||
+ aState.mLoopRemainingCount == 0) {
+ ret.mAnimationFinished = true;
+ }
+
+ nextFrameIndex = 0;
+
+ if (aState.mLoopRemainingCount > 0) {
+ aState.mLoopRemainingCount--;
+ }
+
+ // If we're done, exit early.
+ if (ret.mAnimationFinished) {
+ return ret;
+ }
+ }
+
+ if (nextFrameIndex >= aState.KnownFrameCount()) {
+ // We've already advanced to the last decoded frame, nothing more we can do.
+ // We're blocked by network/decoding from displaying the animation at the
+ // rate specified, so that means the frame we are displaying (the latest
+ // available) is the frame we want to be displaying at this time. So we
+ // update the current animation time. If we didn't update the current
+ // animation time then it could lag behind, which would indicate that we are
+ // behind in the animation and should try to catch up. When we are done
+ // decoding (and thus can loop around back to the start of the animation) we
+ // would then jump to a random point in the animation to try to catch up.
+ // But we were never behind in the animation.
+ aState.mCurrentAnimationFrameTime = aTime;
+ return ret;
+ }
+
+ // There can be frames in the surface cache with index >= KnownFrameCount()
+ // which GetRawFrame() can access because an async decoder has decoded them,
+ // but which AnimationState doesn't know about yet because we haven't received
+ // the appropriate notification on the main thread. Make sure we stay in sync
+ // with AnimationState.
+ MOZ_ASSERT(nextFrameIndex < aState.KnownFrameCount());
+ RefPtr<imgFrame> nextFrame = aFrames.GetFrame(nextFrameIndex);
+
+ // We should always check to see if we have the next frame even if we have
+ // previously finished decoding. If we needed to redecode (e.g. due to a draw
+ // failure) we would have discarded all the old frames and may not yet have
+ // the new ones. DrawableSurface::RawAccessRef promises to only return
+ // finished frames.
+ if (!nextFrame) {
+ // Uh oh, the frame we want to show is currently being decoded (partial).
+ // Similar to the above case, we could be blocked by network or decoding,
+ // and so we should advance our current time rather than risk jumping
+ // through the animation. We will wait until the next refresh driver tick
+ // and try again.
+ aState.mCurrentAnimationFrameTime = aTime;
+ return ret;
+ }
+
+ if (nextFrame->GetTimeout() == FrameTimeout::Forever()) {
+ ret.mAnimationFinished = true;
+ }
+
+ if (nextFrameIndex == 0) {
+ ret.mDirtyRect = aState.FirstFrameRefreshArea();
+ } else {
+ ret.mDirtyRect = nextFrame->GetDirtyRect();
+ }
+
+ aState.mCurrentAnimationFrameTime =
+ GetCurrentImgFrameEndTime(aState, aCurrentFrame->GetTimeout());
+
+ // If we can get closer to the current time by a multiple of the image's loop
+ // time, we should. We can only do this if we're done decoding; otherwise, we
+ // don't know the full loop length, and LoopLength() will have to return
+ // FrameTimeout::Forever(). We also skip this for images with a finite loop
+ // count if we have initialized mLoopRemainingCount (it only gets initialized
+ // after one full loop).
+ FrameTimeout loopTime = aState.LoopLength();
+ if (loopTime != FrameTimeout::Forever() &&
+ (aState.LoopCount() < 0 || aState.mLoopRemainingCount >= 0)) {
+ TimeDuration delay = aTime - aState.mCurrentAnimationFrameTime;
+ if (delay.ToMilliseconds() > loopTime.AsMilliseconds()) {
+ // Explicitly use integer division to get the floor of the number of
+ // loops.
+ uint64_t loops = static_cast<uint64_t>(delay.ToMilliseconds()) /
+ loopTime.AsMilliseconds();
+
+ // If we have a finite loop count limit the number of loops we advance.
+ if (aState.mLoopRemainingCount >= 0) {
+ MOZ_ASSERT(aState.LoopCount() >= 0);
+ loops =
+ std::min(loops, CheckedUint64(aState.mLoopRemainingCount).value());
+ }
+
+ aState.mCurrentAnimationFrameTime +=
+ TimeDuration::FromMilliseconds(loops * loopTime.AsMilliseconds());
+
+ if (aState.mLoopRemainingCount >= 0) {
+ MOZ_ASSERT(loops <= CheckedUint64(aState.mLoopRemainingCount).value());
+ aState.mLoopRemainingCount -= CheckedInt32(loops).value();
+ }
+ }
+ }
+
+ // Set currentAnimationFrameIndex at the last possible moment
+ aState.mCurrentAnimationFrameIndex = nextFrameIndex;
+ aCurrentFrame = std::move(nextFrame);
+ aFrames.Advance(nextFrameIndex);
+
+ // If we're here, we successfully advanced the frame.
+ ret.mFrameAdvanced = true;
+
+ return ret;
+}
+
+void FrameAnimator::ResetAnimation(AnimationState& aState) {
+ aState.ResetAnimation();
+
+ // Our surface provider is synchronized to our state, so we need to reset its
+ // state as well, if we still have one.
+ SurfaceCache::ResetAnimation(
+ ImageKey(mImage),
+ RasterSurfaceKey(mSize, DefaultSurfaceFlags(), PlaybackType::eAnimated));
+
+ // Calling Reset on the surface of the animation can cause discarding surface
+ // providers to throw out all their frames so refresh our state.
+ OrientedIntRect rect =
+ OrientedIntRect::FromUnknownRect(aState.UpdateState(mImage, mSize));
+
+ if (!rect.IsEmpty()) {
+ nsCOMPtr<nsIEventTarget> eventTarget = do_GetMainThread();
+ RefPtr<RasterImage> image = mImage;
+ nsCOMPtr<nsIRunnable> ev = NS_NewRunnableFunction(
+ "FrameAnimator::ResetAnimation",
+ [=]() -> void { image->NotifyProgress(NoProgress, rect); });
+ eventTarget->Dispatch(ev.forget(), NS_DISPATCH_NORMAL);
+ }
+}
+
+RefreshResult FrameAnimator::RequestRefresh(AnimationState& aState,
+ const TimeStamp& aTime) {
+ // By default, an empty RefreshResult.
+ RefreshResult ret;
+
+ if (aState.IsDiscarded()) {
+ aState.MaybeAdvanceAnimationFrameTime(aTime);
+ return ret;
+ }
+
+ // Get the animation frames once now, and pass them down to callees because
+ // the surface could be discarded at anytime on a different thread. This is
+ // must easier to reason about then trying to write code that is safe to
+ // having the surface disappear at anytime.
+ LookupResult result = SurfaceCache::Lookup(
+ ImageKey(mImage),
+ RasterSurfaceKey(mSize, DefaultSurfaceFlags(), PlaybackType::eAnimated),
+ /* aMarkUsed = */ true);
+
+ ret.mDirtyRect = aState.UpdateStateInternal(result, mSize);
+ if (aState.IsDiscarded() || !result) {
+ aState.MaybeAdvanceAnimationFrameTime(aTime);
+ return ret;
+ }
+
+ RefPtr<imgFrame> currentFrame =
+ result.Surface().GetFrame(aState.mCurrentAnimationFrameIndex);
+
+ // only advance the frame if the current time is greater than or
+ // equal to the current frame's end time.
+ if (!currentFrame) {
+ MOZ_ASSERT(StaticPrefs::image_mem_animated_discardable_AtStartup());
+ MOZ_ASSERT(aState.GetHasRequestedDecode() &&
+ !aState.GetIsCurrentlyDecoded());
+ MOZ_ASSERT(aState.mCompositedFrameInvalid);
+ // Nothing we can do but wait for our previous current frame to be decoded
+ // again so we can determine what to do next.
+ aState.MaybeAdvanceAnimationFrameTime(aTime);
+ return ret;
+ }
+
+ TimeStamp currentFrameEndTime =
+ GetCurrentImgFrameEndTime(aState, currentFrame->GetTimeout());
+
+ // If nothing has accessed the composited frame since the last time we
+ // advanced, then there is no point in continuing to advance the animation.
+ // This has the effect of freezing the animation while not in view.
+ if (!result.Surface().MayAdvance() &&
+ aState.MaybeAdvanceAnimationFrameTime(aTime)) {
+ return ret;
+ }
+
+ while (currentFrameEndTime <= aTime) {
+ TimeStamp oldFrameEndTime = currentFrameEndTime;
+
+ RefreshResult frameRes =
+ AdvanceFrame(aState, result.Surface(), currentFrame, aTime);
+
+ // Accumulate our result for returning to callers.
+ ret.Accumulate(frameRes);
+
+ // currentFrame was updated by AdvanceFrame so it is still current.
+ currentFrameEndTime =
+ GetCurrentImgFrameEndTime(aState, currentFrame->GetTimeout());
+
+ // If we didn't advance a frame, and our frame end time didn't change,
+ // then we need to break out of this loop & wait for the frame(s)
+ // to finish downloading.
+ if (!frameRes.mFrameAdvanced && currentFrameEndTime == oldFrameEndTime) {
+ break;
+ }
+ }
+
+ // We should only mark the composited frame as valid and reset the dirty rect
+ // if we advanced (meaning the next frame was actually produced somehow), the
+ // composited frame was previously invalid (so we may need to repaint
+ // everything) and either the frame index is valid (to know we were doing
+ // blending on the main thread, instead of on the decoder threads in advance),
+ // or the current frame is a full frame (blends off the main thread).
+ //
+ // If for some reason we forget to reset aState.mCompositedFrameInvalid, then
+ // GetCompositedFrame will fail, even if we have all the data available for
+ // display.
+ if (currentFrameEndTime > aTime && aState.mCompositedFrameInvalid) {
+ aState.mCompositedFrameInvalid = false;
+ ret.mDirtyRect = IntRect(IntPoint(0, 0), mSize);
+ }
+
+ MOZ_ASSERT(!aState.mIsCurrentlyDecoded || !aState.mCompositedFrameInvalid);
+
+ return ret;
+}
+
+LookupResult FrameAnimator::GetCompositedFrame(AnimationState& aState,
+ bool aMarkUsed) {
+ LookupResult result = SurfaceCache::Lookup(
+ ImageKey(mImage),
+ RasterSurfaceKey(mSize, DefaultSurfaceFlags(), PlaybackType::eAnimated),
+ aMarkUsed);
+
+ if (result) {
+ // If we are getting the frame directly (e.g. through tests or canvas), we
+ // need to ensure the animation is marked to allow advancing to the next
+ // frame.
+ result.Surface().MarkMayAdvance();
+ }
+
+ if (aState.mCompositedFrameInvalid) {
+ MOZ_ASSERT(StaticPrefs::image_mem_animated_discardable_AtStartup());
+ MOZ_ASSERT(aState.GetHasRequestedDecode());
+ MOZ_ASSERT(!aState.GetIsCurrentlyDecoded());
+
+ if (result.Type() == MatchType::EXACT) {
+ // If our composited frame is marked as invalid but our frames are in the
+ // surface cache we might just have not updated our internal state yet.
+ // This can happen if the image is not in a document so that
+ // RequestRefresh is not getting called to advance the frame.
+ // RequestRefresh would result in our composited frame getting marked as
+ // valid either at the end of RequestRefresh when we are able to advance
+ // to the current time or if advancing frames eventually causes us to
+ // decode all of the frames of the image resulting in DecodeComplete
+ // getting called which calls UpdateState. The reason we care about this
+ // is that img.decode promises won't resolve until GetCompositedFrame
+ // returns a frame.
+ OrientedIntRect rect = OrientedIntRect::FromUnknownRect(
+ aState.UpdateStateInternal(result, mSize));
+
+ if (!rect.IsEmpty()) {
+ nsCOMPtr<nsIEventTarget> eventTarget = do_GetMainThread();
+ RefPtr<RasterImage> image = mImage;
+ nsCOMPtr<nsIRunnable> ev = NS_NewRunnableFunction(
+ "FrameAnimator::GetCompositedFrame",
+ [=]() -> void { image->NotifyProgress(NoProgress, rect); });
+ eventTarget->Dispatch(ev.forget(), NS_DISPATCH_NORMAL);
+ }
+ }
+
+ // If it's still invalid we have to return.
+ if (aState.mCompositedFrameInvalid) {
+ if (result.Type() == MatchType::NOT_FOUND) {
+ return result;
+ }
+ return LookupResult(MatchType::PENDING);
+ }
+ }
+
+ // Otherwise return the raw frame. DoBlend is required to ensure that we only
+ // hit this case if the frame is not paletted and doesn't require compositing.
+ if (!result) {
+ return result;
+ }
+
+ // Seek to the appropriate frame. If seeking fails, it means that we couldn't
+ // get the frame we're looking for; treat this as if the lookup failed.
+ if (NS_FAILED(result.Surface().Seek(aState.mCurrentAnimationFrameIndex))) {
+ if (result.Type() == MatchType::NOT_FOUND) {
+ return result;
+ }
+ return LookupResult(MatchType::PENDING);
+ }
+
+ return result;
+}
+
+} // namespace image
+} // namespace mozilla