mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 13:24:12 +00:00
d0d070b48c
MozReview-Commit-ID: JNYZsts6pCO --HG-- extra : rebase_source : d37ce77ec84af302018f95285cff61b2ba28c957
1061 lines
39 KiB
C++
1061 lines
39 KiB
C++
/* -*- 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 "mozilla/MemoryReporting.h"
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/CheckedInt.h"
|
|
#include "imgIContainer.h"
|
|
#include "LookupResult.h"
|
|
#include "MainThreadUtils.h"
|
|
#include "RasterImage.h"
|
|
#include "gfxPrefs.h"
|
|
|
|
#include "pixman.h"
|
|
#include <algorithm>
|
|
|
|
namespace mozilla {
|
|
|
|
using namespace gfx;
|
|
|
|
namespace image {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// AnimationState implementation.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
const gfx::IntRect
|
|
AnimationState::UpdateState(bool aAnimationFinished,
|
|
RasterImage *aImage,
|
|
const gfx::IntSize& aSize,
|
|
bool aAllowInvalidation /* = true */)
|
|
{
|
|
LookupResult result =
|
|
SurfaceCache::Lookup(ImageKey(aImage),
|
|
RasterSurfaceKey(aSize,
|
|
DefaultSurfaceFlags(),
|
|
PlaybackType::eAnimated));
|
|
|
|
return UpdateStateInternal(result, aAnimationFinished, aSize, aAllowInvalidation);
|
|
}
|
|
|
|
const gfx::IntRect
|
|
AnimationState::UpdateStateInternal(LookupResult& aResult,
|
|
bool aAnimationFinished,
|
|
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 mHasBeenDecoded is true then we know the true total frame count and
|
|
// we can use it to determine if we have all the frames now so we know if
|
|
// we are currently fully decoded.
|
|
// If mHasBeenDecoded is false then we'll get another UpdateState call
|
|
// when the decode finishes.
|
|
if (mHasBeenDecoded) {
|
|
Maybe<uint32_t> frameCount = FrameCount();
|
|
MOZ_ASSERT(frameCount.isSome());
|
|
if (NS_SUCCEEDED(aResult.Surface().Seek(*frameCount - 1)) &&
|
|
aResult.Surface()->IsFinished()) {
|
|
mIsCurrentlyDecoded = true;
|
|
} else {
|
|
mIsCurrentlyDecoded = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
gfx::IntRect ret;
|
|
|
|
if (aAllowInvalidation) {
|
|
// Update the value of mCompositedFrameInvalid.
|
|
if (mIsCurrentlyDecoded || aAnimationFinished) {
|
|
// Animated images that have finished their animation (ie because it is a
|
|
// finite length animation) don't have RequestRefresh called on them, and so
|
|
// mCompositedFrameInvalid would never get cleared. We clear it here (and
|
|
// also in RasterImage::Decode when we create a decoder for an image that
|
|
// has finished animated so it can display sooner than waiting until the
|
|
// decode completes). We also do it if we are fully decoded. This is safe
|
|
// to do for images that 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 (aResult.Type() == MatchType::NOT_FOUND ||
|
|
aResult.Type() == MatchType::PENDING) {
|
|
if (mHasRequestedDecode) {
|
|
MOZ_ASSERT(gfxPrefs::ImageMemAnimatedDiscardable());
|
|
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;
|
|
}
|
|
|
|
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.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
Maybe<TimeStamp>
|
|
FrameAnimator::GetCurrentImgFrameEndTime(AnimationState& aState,
|
|
DrawableSurface& aFrames) const
|
|
{
|
|
TimeStamp currentFrameTime = aState.mCurrentAnimationFrameTime;
|
|
Maybe<FrameTimeout> timeout =
|
|
GetTimeoutForFrame(aState, aFrames, aState.mCurrentAnimationFrameIndex);
|
|
|
|
if (timeout.isNothing()) {
|
|
MOZ_ASSERT(aState.GetHasRequestedDecode() && !aState.GetIsCurrentlyDecoded());
|
|
return Nothing();
|
|
}
|
|
|
|
if (*timeout == 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 Some(TimeStamp::NowLoRes() +
|
|
TimeDuration::FromMilliseconds(31536000.0));
|
|
}
|
|
|
|
TimeDuration durationOfTimeout =
|
|
TimeDuration::FromMilliseconds(double(timeout->AsMilliseconds()));
|
|
TimeStamp currentFrameEndTime = currentFrameTime + durationOfTimeout;
|
|
|
|
return Some(currentFrameEndTime);
|
|
}
|
|
|
|
RefreshResult
|
|
FrameAnimator::AdvanceFrame(AnimationState& aState,
|
|
DrawableSurface& aFrames,
|
|
TimeStamp aTime)
|
|
{
|
|
NS_ASSERTION(aTime <= TimeStamp::Now(),
|
|
"Given time appears to be in the future");
|
|
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());
|
|
RawAccessFrameRef nextFrame = GetRawFrame(aFrames, 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.
|
|
if (!nextFrame || !nextFrame->IsFinished()) {
|
|
// Uh oh, the frame we want to show is currently being decoded (partial)
|
|
// Wait until the next refresh driver tick and try again
|
|
return ret;
|
|
}
|
|
|
|
Maybe<FrameTimeout> nextFrameTimeout = GetTimeoutForFrame(aState, aFrames, nextFrameIndex);
|
|
// GetTimeoutForFrame can only return none if frame doesn't exist,
|
|
// but we just got it above.
|
|
MOZ_ASSERT(nextFrameTimeout.isSome());
|
|
if (*nextFrameTimeout == FrameTimeout::Forever()) {
|
|
ret.mAnimationFinished = true;
|
|
}
|
|
|
|
if (nextFrameIndex == 0) {
|
|
ret.mDirtyRect = aState.FirstFrameRefreshArea();
|
|
} else {
|
|
MOZ_ASSERT(nextFrameIndex == currentFrameIndex + 1);
|
|
|
|
// Change frame
|
|
if (!DoBlend(aFrames, &ret.mDirtyRect, currentFrameIndex, nextFrameIndex)) {
|
|
// something went wrong, move on to next
|
|
NS_WARNING("FrameAnimator::AdvanceFrame(): Compositing of frame failed");
|
|
nextFrame->SetCompositingFailed(true);
|
|
Maybe<TimeStamp> currentFrameEndTime = GetCurrentImgFrameEndTime(aState, aFrames);
|
|
MOZ_ASSERT(currentFrameEndTime.isSome());
|
|
aState.mCurrentAnimationFrameTime = *currentFrameEndTime;
|
|
aState.mCurrentAnimationFrameIndex = nextFrameIndex;
|
|
|
|
return ret;
|
|
}
|
|
|
|
nextFrame->SetCompositingFailed(false);
|
|
}
|
|
|
|
Maybe<TimeStamp> currentFrameEndTime = GetCurrentImgFrameEndTime(aState, aFrames);
|
|
MOZ_ASSERT(currentFrameEndTime.isSome());
|
|
aState.mCurrentAnimationFrameTime = *currentFrameEndTime;
|
|
|
|
// 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;
|
|
|
|
// If we're here, we successfully advanced the frame.
|
|
ret.mFrameAdvanced = true;
|
|
|
|
return ret;
|
|
}
|
|
|
|
RefreshResult
|
|
FrameAnimator::RequestRefresh(AnimationState& aState,
|
|
const TimeStamp& aTime,
|
|
bool aAnimationFinished)
|
|
{
|
|
// By default, an empty RefreshResult.
|
|
RefreshResult ret;
|
|
|
|
if (aState.IsDiscarded()) {
|
|
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));
|
|
|
|
ret.mDirtyRect = aState.UpdateStateInternal(result, aAnimationFinished, mSize);
|
|
if (aState.IsDiscarded() || !result) {
|
|
if (!ret.mDirtyRect.IsEmpty()) {
|
|
ret.mFrameAdvanced = true;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// only advance the frame if the current time is greater than or
|
|
// equal to the current frame's end time.
|
|
Maybe<TimeStamp> currentFrameEndTime =
|
|
GetCurrentImgFrameEndTime(aState, result.Surface());
|
|
if (currentFrameEndTime.isNothing()) {
|
|
MOZ_ASSERT(gfxPrefs::ImageMemAnimatedDiscardable());
|
|
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.
|
|
return ret;
|
|
}
|
|
|
|
while (*currentFrameEndTime <= aTime) {
|
|
TimeStamp oldFrameEndTime = *currentFrameEndTime;
|
|
|
|
RefreshResult frameRes = AdvanceFrame(aState, result.Surface(), aTime);
|
|
|
|
// Accumulate our result for returning to callers.
|
|
ret.Accumulate(frameRes);
|
|
|
|
currentFrameEndTime = GetCurrentImgFrameEndTime(aState, result.Surface());
|
|
// AdvanceFrame can't advance to a frame that doesn't exist yet.
|
|
MOZ_ASSERT(currentFrameEndTime.isSome());
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
// Advanced to the correct frame, the composited frame is now valid to be drawn.
|
|
if (*currentFrameEndTime > aTime) {
|
|
aState.mCompositedFrameInvalid = false;
|
|
ret.mDirtyRect = IntRect(IntPoint(0,0), mSize);
|
|
}
|
|
|
|
MOZ_ASSERT(!aState.mIsCurrentlyDecoded || !aState.mCompositedFrameInvalid);
|
|
|
|
return ret;
|
|
}
|
|
|
|
LookupResult
|
|
FrameAnimator::GetCompositedFrame(AnimationState& aState)
|
|
{
|
|
LookupResult result =
|
|
SurfaceCache::Lookup(ImageKey(mImage),
|
|
RasterSurfaceKey(mSize,
|
|
DefaultSurfaceFlags(),
|
|
PlaybackType::eAnimated));
|
|
|
|
if (aState.mCompositedFrameInvalid) {
|
|
MOZ_ASSERT(gfxPrefs::ImageMemAnimatedDiscardable());
|
|
MOZ_ASSERT(aState.GetHasRequestedDecode());
|
|
MOZ_ASSERT(!aState.GetIsCurrentlyDecoded());
|
|
if (result.Type() == MatchType::NOT_FOUND) {
|
|
return result;
|
|
}
|
|
return LookupResult(MatchType::PENDING);
|
|
}
|
|
|
|
// If we have a composited version of this frame, return that.
|
|
if (mLastCompositedFrameIndex >= 0 &&
|
|
(uint32_t(mLastCompositedFrameIndex) == aState.mCurrentAnimationFrameIndex)) {
|
|
return LookupResult(DrawableSurface(mCompositingFrame->DrawableRef()),
|
|
MatchType::EXACT);
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
MOZ_ASSERT(!result.Surface()->GetIsPaletted(),
|
|
"About to return a paletted frame");
|
|
|
|
return result;
|
|
}
|
|
|
|
Maybe<FrameTimeout>
|
|
FrameAnimator::GetTimeoutForFrame(AnimationState& aState,
|
|
DrawableSurface& aFrames,
|
|
uint32_t aFrameNum) const
|
|
{
|
|
RawAccessFrameRef frame = GetRawFrame(aFrames, aFrameNum);
|
|
if (frame) {
|
|
AnimationData data = frame->GetAnimationData();
|
|
return Some(data.mTimeout);
|
|
}
|
|
|
|
MOZ_ASSERT(aState.mHasRequestedDecode && !aState.mIsCurrentlyDecoded);
|
|
return Nothing();
|
|
}
|
|
|
|
static void
|
|
DoCollectSizeOfCompositingSurfaces(const RawAccessFrameRef& aSurface,
|
|
SurfaceMemoryCounterType aType,
|
|
nsTArray<SurfaceMemoryCounter>& aCounters,
|
|
MallocSizeOf aMallocSizeOf)
|
|
{
|
|
// Concoct a SurfaceKey for this surface.
|
|
SurfaceKey key = RasterSurfaceKey(aSurface->GetImageSize(),
|
|
DefaultSurfaceFlags(),
|
|
PlaybackType::eStatic);
|
|
|
|
// Create a counter for this surface.
|
|
SurfaceMemoryCounter counter(key, /* aIsLocked = */ true,
|
|
/* aCannotSubstitute */ false,
|
|
/* aIsFactor2 */ false, aType);
|
|
|
|
// Extract the surface's memory usage information.
|
|
size_t heap = 0, nonHeap = 0, handles = 0;
|
|
aSurface->AddSizeOfExcludingThis(aMallocSizeOf, heap, nonHeap, handles);
|
|
counter.Values().SetDecodedHeap(heap);
|
|
counter.Values().SetDecodedNonHeap(nonHeap);
|
|
counter.Values().SetSharedHandles(handles);
|
|
|
|
// Record it.
|
|
aCounters.AppendElement(counter);
|
|
}
|
|
|
|
void
|
|
FrameAnimator::CollectSizeOfCompositingSurfaces(
|
|
nsTArray<SurfaceMemoryCounter>& aCounters,
|
|
MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
if (mCompositingFrame) {
|
|
DoCollectSizeOfCompositingSurfaces(mCompositingFrame,
|
|
SurfaceMemoryCounterType::COMPOSITING,
|
|
aCounters,
|
|
aMallocSizeOf);
|
|
}
|
|
|
|
if (mCompositingPrevFrame) {
|
|
DoCollectSizeOfCompositingSurfaces(mCompositingPrevFrame,
|
|
SurfaceMemoryCounterType::COMPOSITING_PREV,
|
|
aCounters,
|
|
aMallocSizeOf);
|
|
}
|
|
}
|
|
|
|
RawAccessFrameRef
|
|
FrameAnimator::GetRawFrame(DrawableSurface& aFrames, uint32_t aFrameNum) const
|
|
{
|
|
// Seek to the frame we want. If seeking fails, it means we couldn't get the
|
|
// frame we're looking for, so we bail here to avoid returning the wrong frame
|
|
// to the caller.
|
|
if (NS_FAILED(aFrames.Seek(aFrameNum))) {
|
|
return RawAccessFrameRef(); // Not available yet.
|
|
}
|
|
|
|
return aFrames->RawAccessRef();
|
|
}
|
|
|
|
//******************************************************************************
|
|
// DoBlend gets called when the timer for animation get fired and we have to
|
|
// update the composited frame of the animation.
|
|
bool
|
|
FrameAnimator::DoBlend(DrawableSurface& aFrames,
|
|
IntRect* aDirtyRect,
|
|
uint32_t aPrevFrameIndex,
|
|
uint32_t aNextFrameIndex)
|
|
{
|
|
RawAccessFrameRef prevFrame = GetRawFrame(aFrames, aPrevFrameIndex);
|
|
RawAccessFrameRef nextFrame = GetRawFrame(aFrames, aNextFrameIndex);
|
|
|
|
MOZ_ASSERT(prevFrame && nextFrame, "Should have frames here");
|
|
|
|
AnimationData prevFrameData = prevFrame->GetAnimationData();
|
|
if (prevFrameData.mDisposalMethod == DisposalMethod::RESTORE_PREVIOUS &&
|
|
!mCompositingPrevFrame) {
|
|
prevFrameData.mDisposalMethod = DisposalMethod::CLEAR;
|
|
}
|
|
|
|
IntRect prevRect = prevFrameData.mBlendRect
|
|
? prevFrameData.mRect.Intersect(*prevFrameData.mBlendRect)
|
|
: prevFrameData.mRect;
|
|
|
|
bool isFullPrevFrame = prevRect.IsEqualRect(0, 0, mSize.width, mSize.height);
|
|
|
|
// Optimization: DisposeClearAll if the previous frame is the same size as
|
|
// container and it's clearing itself
|
|
if (isFullPrevFrame &&
|
|
(prevFrameData.mDisposalMethod == DisposalMethod::CLEAR)) {
|
|
prevFrameData.mDisposalMethod = DisposalMethod::CLEAR_ALL;
|
|
}
|
|
|
|
AnimationData nextFrameData = nextFrame->GetAnimationData();
|
|
|
|
IntRect nextRect = nextFrameData.mBlendRect
|
|
? nextFrameData.mRect.Intersect(*nextFrameData.mBlendRect)
|
|
: nextFrameData.mRect;
|
|
|
|
bool isFullNextFrame = nextRect.IsEqualRect(0, 0, mSize.width, mSize.height);
|
|
|
|
if (!nextFrame->GetIsPaletted()) {
|
|
// Optimization: Skip compositing if the previous frame wants to clear the
|
|
// whole image
|
|
if (prevFrameData.mDisposalMethod == DisposalMethod::CLEAR_ALL) {
|
|
aDirtyRect->SetRect(0, 0, mSize.width, mSize.height);
|
|
return true;
|
|
}
|
|
|
|
// Optimization: Skip compositing if this frame is the same size as the
|
|
// container and it's fully drawing over prev frame (no alpha)
|
|
if (isFullNextFrame &&
|
|
(nextFrameData.mDisposalMethod != DisposalMethod::RESTORE_PREVIOUS) &&
|
|
!nextFrameData.mHasAlpha) {
|
|
aDirtyRect->SetRect(0, 0, mSize.width, mSize.height);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Calculate area that needs updating
|
|
switch (prevFrameData.mDisposalMethod) {
|
|
default:
|
|
MOZ_FALLTHROUGH_ASSERT("Unexpected DisposalMethod");
|
|
case DisposalMethod::NOT_SPECIFIED:
|
|
case DisposalMethod::KEEP:
|
|
*aDirtyRect = nextRect;
|
|
break;
|
|
|
|
case DisposalMethod::CLEAR_ALL:
|
|
// Whole image container is cleared
|
|
aDirtyRect->SetRect(0, 0, mSize.width, mSize.height);
|
|
break;
|
|
|
|
case DisposalMethod::CLEAR:
|
|
// Calc area that needs to be redrawn (the combination of previous and
|
|
// this frame)
|
|
// XXX - This could be done with multiple framechanged calls
|
|
// Having prevFrame way at the top of the image, and nextFrame
|
|
// way at the bottom, and both frames being small, we'd be
|
|
// telling framechanged to refresh the whole image when only two
|
|
// small areas are needed.
|
|
aDirtyRect->UnionRect(nextRect, prevRect);
|
|
break;
|
|
|
|
case DisposalMethod::RESTORE_PREVIOUS:
|
|
aDirtyRect->SetRect(0, 0, mSize.width, mSize.height);
|
|
break;
|
|
}
|
|
|
|
// Optimization:
|
|
// Skip compositing if the last composited frame is this frame
|
|
// (Only one composited frame was made for this animation. Example:
|
|
// Only Frame 3 of a 10 frame image required us to build a composite frame
|
|
// On the second loop, we do not need to rebuild the frame
|
|
// since it's still sitting in compositingFrame)
|
|
if (mLastCompositedFrameIndex == int32_t(aNextFrameIndex)) {
|
|
return true;
|
|
}
|
|
|
|
bool needToBlankComposite = false;
|
|
|
|
// Create the Compositing Frame
|
|
if (!mCompositingFrame) {
|
|
RefPtr<imgFrame> newFrame = new imgFrame;
|
|
nsresult rv = newFrame->InitForAnimator(mSize,
|
|
SurfaceFormat::B8G8R8A8);
|
|
if (NS_FAILED(rv)) {
|
|
mCompositingFrame.reset();
|
|
return false;
|
|
}
|
|
mCompositingFrame = newFrame->RawAccessRef();
|
|
needToBlankComposite = true;
|
|
} else if (int32_t(aNextFrameIndex) != mLastCompositedFrameIndex+1) {
|
|
|
|
// If we are not drawing on top of last composited frame,
|
|
// then we are building a new composite frame, so let's clear it first.
|
|
needToBlankComposite = true;
|
|
}
|
|
|
|
AnimationData compositingFrameData = mCompositingFrame->GetAnimationData();
|
|
|
|
// More optimizations possible when next frame is not transparent
|
|
// But if the next frame has DisposalMethod::RESTORE_PREVIOUS,
|
|
// this "no disposal" optimization is not possible,
|
|
// because the frame in "after disposal operation" state
|
|
// needs to be stored in compositingFrame, so it can be
|
|
// copied into compositingPrevFrame later.
|
|
bool doDisposal = true;
|
|
if (!nextFrameData.mHasAlpha &&
|
|
nextFrameData.mDisposalMethod != DisposalMethod::RESTORE_PREVIOUS) {
|
|
if (isFullNextFrame) {
|
|
// Optimization: No need to dispose prev.frame when
|
|
// next frame is full frame and not transparent.
|
|
doDisposal = false;
|
|
// No need to blank the composite frame
|
|
needToBlankComposite = false;
|
|
} else {
|
|
if ((prevRect.X() >= nextRect.X()) && (prevRect.Y() >= nextRect.Y()) &&
|
|
(prevRect.XMost() <= nextRect.XMost()) &&
|
|
(prevRect.YMost() <= nextRect.YMost())) {
|
|
// Optimization: No need to dispose prev.frame when
|
|
// next frame fully overlaps previous frame.
|
|
doDisposal = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (doDisposal) {
|
|
// Dispose of previous: clear, restore, or keep (copy)
|
|
switch (prevFrameData.mDisposalMethod) {
|
|
case DisposalMethod::CLEAR:
|
|
if (needToBlankComposite) {
|
|
// If we just created the composite, it could have anything in its
|
|
// buffer. Clear whole frame
|
|
ClearFrame(compositingFrameData.mRawData,
|
|
compositingFrameData.mRect);
|
|
} else {
|
|
// Only blank out previous frame area (both color & Mask/Alpha)
|
|
ClearFrame(compositingFrameData.mRawData,
|
|
compositingFrameData.mRect,
|
|
prevRect);
|
|
}
|
|
break;
|
|
|
|
case DisposalMethod::CLEAR_ALL:
|
|
ClearFrame(compositingFrameData.mRawData,
|
|
compositingFrameData.mRect);
|
|
break;
|
|
|
|
case DisposalMethod::RESTORE_PREVIOUS:
|
|
// It would be better to copy only the area changed back to
|
|
// compositingFrame.
|
|
if (mCompositingPrevFrame) {
|
|
AnimationData compositingPrevFrameData =
|
|
mCompositingPrevFrame->GetAnimationData();
|
|
|
|
CopyFrameImage(compositingPrevFrameData.mRawData,
|
|
compositingPrevFrameData.mRect,
|
|
compositingFrameData.mRawData,
|
|
compositingFrameData.mRect);
|
|
|
|
// destroy only if we don't need it for this frame's disposal
|
|
if (nextFrameData.mDisposalMethod !=
|
|
DisposalMethod::RESTORE_PREVIOUS) {
|
|
mCompositingPrevFrame.reset();
|
|
}
|
|
} else {
|
|
ClearFrame(compositingFrameData.mRawData,
|
|
compositingFrameData.mRect);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
MOZ_FALLTHROUGH_ASSERT("Unexpected DisposalMethod");
|
|
case DisposalMethod::NOT_SPECIFIED:
|
|
case DisposalMethod::KEEP:
|
|
// Copy previous frame into compositingFrame before we put the new
|
|
// frame on top
|
|
// Assumes that the previous frame represents a full frame (it could be
|
|
// smaller in size than the container, as long as the frame before it
|
|
// erased itself)
|
|
// Note: Frame 1 never gets into DoBlend(), so (aNextFrameIndex - 1)
|
|
// will always be a valid frame number.
|
|
if (mLastCompositedFrameIndex != int32_t(aNextFrameIndex - 1)) {
|
|
if (isFullPrevFrame && !prevFrame->GetIsPaletted()) {
|
|
// Just copy the bits
|
|
CopyFrameImage(prevFrameData.mRawData,
|
|
prevRect,
|
|
compositingFrameData.mRawData,
|
|
compositingFrameData.mRect);
|
|
} else {
|
|
if (needToBlankComposite) {
|
|
// Only blank composite when prev is transparent or not full.
|
|
if (prevFrameData.mHasAlpha || !isFullPrevFrame) {
|
|
ClearFrame(compositingFrameData.mRawData,
|
|
compositingFrameData.mRect);
|
|
}
|
|
}
|
|
DrawFrameTo(prevFrameData.mRawData, prevFrameData.mRect,
|
|
prevFrameData.mPaletteDataLength,
|
|
prevFrameData.mHasAlpha,
|
|
compositingFrameData.mRawData,
|
|
compositingFrameData.mRect,
|
|
prevFrameData.mBlendMethod,
|
|
prevFrameData.mBlendRect);
|
|
}
|
|
}
|
|
}
|
|
} else if (needToBlankComposite) {
|
|
// If we just created the composite, it could have anything in its
|
|
// buffers. Clear them
|
|
ClearFrame(compositingFrameData.mRawData,
|
|
compositingFrameData.mRect);
|
|
}
|
|
|
|
// Check if the frame we are composing wants the previous image restored after
|
|
// it is done. Don't store it (again) if last frame wanted its image restored
|
|
// too
|
|
if ((nextFrameData.mDisposalMethod == DisposalMethod::RESTORE_PREVIOUS) &&
|
|
(prevFrameData.mDisposalMethod != DisposalMethod::RESTORE_PREVIOUS)) {
|
|
// We are storing the whole image.
|
|
// It would be better if we just stored the area that nextFrame is going to
|
|
// overwrite.
|
|
if (!mCompositingPrevFrame) {
|
|
RefPtr<imgFrame> newFrame = new imgFrame;
|
|
nsresult rv = newFrame->InitForAnimator(mSize,
|
|
SurfaceFormat::B8G8R8A8);
|
|
if (NS_FAILED(rv)) {
|
|
mCompositingPrevFrame.reset();
|
|
return false;
|
|
}
|
|
|
|
mCompositingPrevFrame = newFrame->RawAccessRef();
|
|
}
|
|
|
|
AnimationData compositingPrevFrameData =
|
|
mCompositingPrevFrame->GetAnimationData();
|
|
|
|
CopyFrameImage(compositingFrameData.mRawData,
|
|
compositingFrameData.mRect,
|
|
compositingPrevFrameData.mRawData,
|
|
compositingPrevFrameData.mRect);
|
|
|
|
mCompositingPrevFrame->Finish();
|
|
}
|
|
|
|
// blit next frame into it's correct spot
|
|
DrawFrameTo(nextFrameData.mRawData, nextFrameData.mRect,
|
|
nextFrameData.mPaletteDataLength,
|
|
nextFrameData.mHasAlpha,
|
|
compositingFrameData.mRawData,
|
|
compositingFrameData.mRect,
|
|
nextFrameData.mBlendMethod,
|
|
nextFrameData.mBlendRect);
|
|
|
|
// Tell the image that it is fully 'downloaded'.
|
|
mCompositingFrame->Finish();
|
|
|
|
mLastCompositedFrameIndex = int32_t(aNextFrameIndex);
|
|
|
|
return true;
|
|
}
|
|
|
|
//******************************************************************************
|
|
// Fill aFrame with black. Does also clears the mask.
|
|
void
|
|
FrameAnimator::ClearFrame(uint8_t* aFrameData, const IntRect& aFrameRect)
|
|
{
|
|
if (!aFrameData) {
|
|
return;
|
|
}
|
|
|
|
memset(aFrameData, 0, aFrameRect.Width() * aFrameRect.Height() * 4);
|
|
}
|
|
|
|
//******************************************************************************
|
|
void
|
|
FrameAnimator::ClearFrame(uint8_t* aFrameData, const IntRect& aFrameRect,
|
|
const IntRect& aRectToClear)
|
|
{
|
|
if (!aFrameData || aFrameRect.Width() <= 0 || aFrameRect.Height() <= 0 ||
|
|
aRectToClear.Width() <= 0 || aRectToClear.Height() <= 0) {
|
|
return;
|
|
}
|
|
|
|
IntRect toClear = aFrameRect.Intersect(aRectToClear);
|
|
if (toClear.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
uint32_t bytesPerRow = aFrameRect.Width() * 4;
|
|
for (int row = toClear.Y(); row < toClear.YMost(); ++row) {
|
|
memset(aFrameData + toClear.X() * 4 + row * bytesPerRow, 0,
|
|
toClear.Width() * 4);
|
|
}
|
|
}
|
|
|
|
//******************************************************************************
|
|
// Whether we succeed or fail will not cause a crash, and there's not much
|
|
// we can do about a failure, so there we don't return a nsresult
|
|
bool
|
|
FrameAnimator::CopyFrameImage(const uint8_t* aDataSrc,
|
|
const IntRect& aRectSrc,
|
|
uint8_t* aDataDest,
|
|
const IntRect& aRectDest)
|
|
{
|
|
uint32_t dataLengthSrc = aRectSrc.Width() * aRectSrc.Height() * 4;
|
|
uint32_t dataLengthDest = aRectDest.Width() * aRectDest.Height() * 4;
|
|
|
|
if (!aDataDest || !aDataSrc || dataLengthSrc != dataLengthDest) {
|
|
return false;
|
|
}
|
|
|
|
memcpy(aDataDest, aDataSrc, dataLengthDest);
|
|
|
|
return true;
|
|
}
|
|
|
|
nsresult
|
|
FrameAnimator::DrawFrameTo(const uint8_t* aSrcData, const IntRect& aSrcRect,
|
|
uint32_t aSrcPaletteLength, bool aSrcHasAlpha,
|
|
uint8_t* aDstPixels, const IntRect& aDstRect,
|
|
BlendMethod aBlendMethod, const Maybe<IntRect>& aBlendRect)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aSrcData);
|
|
NS_ENSURE_ARG_POINTER(aDstPixels);
|
|
|
|
// According to both AGIF and APNG specs, offsets are unsigned
|
|
if (aSrcRect.X() < 0 || aSrcRect.Y() < 0) {
|
|
NS_WARNING("FrameAnimator::DrawFrameTo: negative offsets not allowed");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Outside the destination frame, skip it
|
|
if ((aSrcRect.X() > aDstRect.Width()) || (aSrcRect.Y() > aDstRect.Height())) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aSrcPaletteLength) {
|
|
// Larger than the destination frame, clip it
|
|
int32_t width = std::min(aSrcRect.Width(), aDstRect.Width() - aSrcRect.X());
|
|
int32_t height = std::min(aSrcRect.Height(), aDstRect.Height() - aSrcRect.Y());
|
|
|
|
// The clipped image must now fully fit within destination image frame
|
|
NS_ASSERTION((aSrcRect.X() >= 0) && (aSrcRect.Y() >= 0) &&
|
|
(aSrcRect.X() + width <= aDstRect.Width()) &&
|
|
(aSrcRect.Y() + height <= aDstRect.Height()),
|
|
"FrameAnimator::DrawFrameTo: Invalid aSrcRect");
|
|
|
|
// clipped image size may be smaller than source, but not larger
|
|
NS_ASSERTION((width <= aSrcRect.Width()) && (height <= aSrcRect.Height()),
|
|
"FrameAnimator::DrawFrameTo: source must be smaller than dest");
|
|
|
|
// Get pointers to image data
|
|
const uint8_t* srcPixels = aSrcData + aSrcPaletteLength;
|
|
uint32_t* dstPixels = reinterpret_cast<uint32_t*>(aDstPixels);
|
|
const uint32_t* colormap = reinterpret_cast<const uint32_t*>(aSrcData);
|
|
|
|
// Skip to the right offset
|
|
dstPixels += aSrcRect.X() + (aSrcRect.Y() * aDstRect.Width());
|
|
if (!aSrcHasAlpha) {
|
|
for (int32_t r = height; r > 0; --r) {
|
|
for (int32_t c = 0; c < width; c++) {
|
|
dstPixels[c] = colormap[srcPixels[c]];
|
|
}
|
|
// Go to the next row in the source resp. destination image
|
|
srcPixels += aSrcRect.Width();
|
|
dstPixels += aDstRect.Width();
|
|
}
|
|
} else {
|
|
for (int32_t r = height; r > 0; --r) {
|
|
for (int32_t c = 0; c < width; c++) {
|
|
const uint32_t color = colormap[srcPixels[c]];
|
|
if (color) {
|
|
dstPixels[c] = color;
|
|
}
|
|
}
|
|
// Go to the next row in the source resp. destination image
|
|
srcPixels += aSrcRect.Width();
|
|
dstPixels += aDstRect.Width();
|
|
}
|
|
}
|
|
} else {
|
|
pixman_image_t* src =
|
|
pixman_image_create_bits(
|
|
aSrcHasAlpha ? PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8,
|
|
aSrcRect.Width(), aSrcRect.Height(),
|
|
reinterpret_cast<uint32_t*>(const_cast<uint8_t*>(aSrcData)),
|
|
aSrcRect.Width() * 4);
|
|
if (!src) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
pixman_image_t* dst =
|
|
pixman_image_create_bits(PIXMAN_a8r8g8b8,
|
|
aDstRect.Width(),
|
|
aDstRect.Height(),
|
|
reinterpret_cast<uint32_t*>(aDstPixels),
|
|
aDstRect.Width() * 4);
|
|
if (!dst) {
|
|
pixman_image_unref(src);
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
// XXX(seth): This is inefficient but we'll remove it quite soon when we
|
|
// move frame compositing into SurfacePipe. For now we need this because
|
|
// RemoveFrameRectFilter has transformed PNG frames with frame rects into
|
|
// imgFrame's with no frame rects, but with a region of 0 alpha where the
|
|
// frame rect should be. This works really nicely if we're using
|
|
// BlendMethod::OVER, but BlendMethod::SOURCE will result in that frame rect
|
|
// area overwriting the previous frame, which makes the animation look
|
|
// wrong. This quick hack fixes that by first compositing the whle new frame
|
|
// with BlendMethod::OVER, and then recopying the area that uses
|
|
// BlendMethod::SOURCE if needed. To make this work, the decoder has to
|
|
// provide a "blend rect" that tells us where to do this. This is just the
|
|
// frame rect, but hidden in a way that makes it invisible to most of the
|
|
// system, so we can keep eliminating dependencies on it.
|
|
auto op = aBlendMethod == BlendMethod::SOURCE ? PIXMAN_OP_SRC
|
|
: PIXMAN_OP_OVER;
|
|
|
|
if (aBlendMethod == BlendMethod::OVER || !aBlendRect ||
|
|
(aBlendMethod == BlendMethod::SOURCE && aSrcRect.IsEqualEdges(*aBlendRect))) {
|
|
// We don't need to do anything clever. (Or, in the case where no blend
|
|
// rect was specified, we can't.)
|
|
pixman_image_composite32(op,
|
|
src,
|
|
nullptr,
|
|
dst,
|
|
0, 0,
|
|
0, 0,
|
|
aSrcRect.X(), aSrcRect.Y(),
|
|
aSrcRect.Width(), aSrcRect.Height());
|
|
} else {
|
|
// We need to do the OVER followed by SOURCE trick above.
|
|
pixman_image_composite32(PIXMAN_OP_OVER,
|
|
src,
|
|
nullptr,
|
|
dst,
|
|
0, 0,
|
|
0, 0,
|
|
aSrcRect.X(), aSrcRect.Y(),
|
|
aSrcRect.Width(), aSrcRect.Height());
|
|
pixman_image_composite32(PIXMAN_OP_SRC,
|
|
src,
|
|
nullptr,
|
|
dst,
|
|
aBlendRect->X(), aBlendRect->Y(),
|
|
0, 0,
|
|
aBlendRect->X(), aBlendRect->Y(),
|
|
aBlendRect->Width(), aBlendRect->Height());
|
|
}
|
|
|
|
pixman_image_unref(src);
|
|
pixman_image_unref(dst);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
} // namespace image
|
|
} // namespace mozilla
|