diff options
Diffstat (limited to 'image/FrameAnimator.cpp')
| -rw-r--r-- | image/FrameAnimator.cpp | 519 |
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 |