Source code

Revision control

Other Tools

/* -*- 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 "AnimationFrameBuffer.h"
#include <utility> // for Move
namespace mozilla {
namespace image {
AnimationFrameRetainedBuffer::AnimationFrameRetainedBuffer(size_t aThreshold,
size_t aBatch,
size_t aStartFrame)
: AnimationFrameBuffer(aBatch, aStartFrame), mThreshold(aThreshold) {
// To simplify the code, we have the assumption that the threshold for
// entering discard-after-display mode is at least twice the batch size (since
// that is the most frames-pending-decode we will request) + 1 for the current
// frame. That way the redecoded frames being inserted will never risk
// overlapping the frames we will discard due to the animation progressing.
// That may cause us to use a little more memory than we want but that is an
// acceptable tradeoff for simplicity.
size_t minThreshold = 2 * mBatch + 1;
if (mThreshold < minThreshold) {
mThreshold = minThreshold;
}
// The maximum number of frames we should ever have decoded at one time is
// twice the batch. That is a good as number as any to start our decoding at.
mPending = mBatch * 2;
}
bool AnimationFrameRetainedBuffer::InsertInternal(RefPtr<imgFrame>&& aFrame) {
// We should only insert new frames if we actually asked for them.
MOZ_ASSERT(!mSizeKnown);
MOZ_ASSERT(mFrames.Length() < mThreshold);
++mSize;
mFrames.AppendElement(std::move(aFrame));
MOZ_ASSERT(mSize == mFrames.Length());
return mSize < mThreshold;
}
bool AnimationFrameRetainedBuffer::ResetInternal() {
// If we haven't crossed the threshold, then we know by definition we have
// not discarded any frames. If we previously requested more frames, but
// it would have been more than we would have buffered otherwise, we can
// stop the decoding after one more frame.
if (mPending > 1 && mSize >= mBatch * 2 + 1) {
MOZ_ASSERT(!mSizeKnown);
mPending = 1;
}
// Either the decoder is still running, or we have enough frames already.
// No need for us to restart it.
return false;
}
bool AnimationFrameRetainedBuffer::MarkComplete(
const gfx::IntRect& aFirstFrameRefreshArea) {
MOZ_ASSERT(!mSizeKnown);
mFirstFrameRefreshArea = aFirstFrameRefreshArea;
mSizeKnown = true;
mPending = 0;
mFrames.Compact();
return false;
}
void AnimationFrameRetainedBuffer::AdvanceInternal() {
// We should not have advanced if we never inserted.
MOZ_ASSERT(!mFrames.IsEmpty());
// We only want to change the current frame index if we have advanced. This
// means either a higher frame index, or going back to the beginning.
size_t framesLength = mFrames.Length();
// We should never have advanced beyond the frame buffer.
MOZ_ASSERT(mGetIndex < framesLength);
// We should never advance if the current frame is null -- it needs to know
// the timeout from it at least to know when to advance.
MOZ_ASSERT_IF(mGetIndex > 0, mFrames[mGetIndex - 1]);
MOZ_ASSERT_IF(mGetIndex == 0, mFrames[framesLength - 1]);
// The owner should have already accessed the next frame, so it should also
// be available.
MOZ_ASSERT(mFrames[mGetIndex]);
if (!mSizeKnown) {
// Calculate how many frames we have requested ahead of the current frame.
size_t buffered = mPending + framesLength - mGetIndex - 1;
if (buffered < mBatch) {
// If we have fewer frames than the batch size, then ask for more. If we
// do not have any pending, then we know that there is no active decoding.
mPending += mBatch;
}
}
}
imgFrame* AnimationFrameRetainedBuffer::Get(size_t aFrame, bool aForDisplay) {
// We should not have asked for a frame if we never inserted.
if (mFrames.IsEmpty()) {
MOZ_ASSERT_UNREACHABLE("Calling Get() when we have no frames");
return nullptr;
}
// If we don't have that frame, return an empty frame ref.
if (aFrame >= mFrames.Length()) {
return nullptr;
}
// If we have space for the frame, it should always be available.
if (!mFrames[aFrame]) {
MOZ_ASSERT_UNREACHABLE("Calling Get() when frame is unavailable");
return nullptr;
}
// If we are advancing on behalf of the animation, we don't expect it to be
// getting any frames (besides the first) until we get the desired frame.
MOZ_ASSERT(aFrame == 0 || mAdvance == 0);
return mFrames[aFrame].get();
}
bool AnimationFrameRetainedBuffer::IsFirstFrameFinished() const {
return !mFrames.IsEmpty() && mFrames[0]->IsFinished();
}
bool AnimationFrameRetainedBuffer::IsLastInsertedFrame(imgFrame* aFrame) const {
return !mFrames.IsEmpty() && mFrames.LastElement().get() == aFrame;
}
void AnimationFrameRetainedBuffer::AddSizeOfExcludingThis(
MallocSizeOf aMallocSizeOf, const AddSizeOfCb& aCallback) {
size_t i = 0;
for (const RefPtr<imgFrame>& frame : mFrames) {
++i;
frame->AddSizeOfExcludingThis(aMallocSizeOf,
[&](AddSizeOfCbData& aMetadata) {
aMetadata.mIndex = i;
aCallback(aMetadata);
});
}
}
AnimationFrameDiscardingQueue::AnimationFrameDiscardingQueue(
AnimationFrameRetainedBuffer&& aQueue)
: AnimationFrameBuffer(aQueue),
mInsertIndex(aQueue.mFrames.Length()),
mFirstFrame(aQueue.mFrames[0]) {
MOZ_ASSERT(!mSizeKnown);
MOZ_ASSERT(!mRedecodeError);
MOZ_ASSERT(mInsertIndex > 0);
mMayDiscard = true;
// We avoided moving aQueue.mFrames[0] for mFirstFrame above because it is
// possible the animation was reset back to the beginning, and then we crossed
// the threshold without advancing further. That would mean mGetIndex is 0.
for (size_t i = mGetIndex; i < mInsertIndex; ++i) {
MOZ_ASSERT(aQueue.mFrames[i]);
mDisplay.push_back(std::move(aQueue.mFrames[i]));
}
}
bool AnimationFrameDiscardingQueue::InsertInternal(RefPtr<imgFrame>&& aFrame) {
if (mInsertIndex == mSize) {
if (mSizeKnown) {
// We produced more frames on a subsequent decode than on the first pass.
mRedecodeError = true;
mPending = 0;
return true;
}
++mSize;
}
// Even though we don't use redecoded first frames for display purposes, we
// will still use them for recycling, so we still need to insert it.
mDisplay.push_back(std::move(aFrame));
++mInsertIndex;
MOZ_ASSERT(mInsertIndex <= mSize);
return true;
}
bool AnimationFrameDiscardingQueue::ResetInternal() {
mDisplay.clear();
mInsertIndex = 0;
bool restartDecoder = mPending == 0;
mPending = 2 * mBatch;
return restartDecoder;
}
bool AnimationFrameDiscardingQueue::MarkComplete(
const gfx::IntRect& aFirstFrameRefreshArea) {
if (NS_WARN_IF(mInsertIndex != mSize)) {
mRedecodeError = true;
mPending = 0;
}
// If we encounter a redecode error, just make the first frame refresh area to
// be the full frame, because we don't really know what we can safely recycle.
mFirstFrameRefreshArea =
mRedecodeError ? mFirstFrame->GetRect() : aFirstFrameRefreshArea;
// We reached the end of the animation, the next frame we get, if we get
// another, will be the first frame again.
mInsertIndex = 0;
mSizeKnown = true;
// Since we only request advancing when we want to resume at a certain point
// in the animation, we should never exceed the number of frames.
MOZ_ASSERT(mAdvance == 0);
return mPending > 0;
}
void AnimationFrameDiscardingQueue::AdvanceInternal() {
// We only want to change the current frame index if we have advanced. This
// means either a higher frame index, or going back to the beginning.
// We should never have advanced beyond the frame buffer.
MOZ_ASSERT(mGetIndex < mSize);
// We should have the current frame still in the display queue. Either way,
// we should at least have an entry in the queue which we need to consume.
MOZ_ASSERT(!mDisplay.empty());
MOZ_ASSERT(mDisplay.front());
mDisplay.pop_front();
MOZ_ASSERT(!mDisplay.empty());
MOZ_ASSERT(mDisplay.front());
if (mDisplay.size() + mPending - 1 < mBatch) {
// If we have fewer frames than the batch size, then ask for more. If we
// do not have any pending, then we know that there is no active decoding.
mPending += mBatch;
}
}
imgFrame* AnimationFrameDiscardingQueue::Get(size_t aFrame, bool aForDisplay) {
// The first frame is stored separately. If we only need the frame for
// display purposes, we can return it right away. If we need it for advancing
// the animation, we want to verify the recreated first frame is available
// before allowing it continue.
if (aForDisplay && aFrame == 0) {
return mFirstFrame.get();
}
// If we don't have that frame, return an empty frame ref.
if (aFrame >= mSize) {
return nullptr;
}
size_t offset;
if (aFrame >= mGetIndex) {
offset = aFrame - mGetIndex;
} else if (!mSizeKnown) {
MOZ_ASSERT_UNREACHABLE("Requesting previous frame after we have advanced!");
return nullptr;
} else {
offset = mSize - mGetIndex + aFrame;
}
if (offset >= mDisplay.size()) {
return nullptr;
}
// If we are advancing on behalf of the animation, we don't expect it to be
// getting any frames (besides the first) until we get the desired frame.
MOZ_ASSERT(aFrame == 0 || mAdvance == 0);
// If we have space for the frame, it should always be available.
MOZ_ASSERT(mDisplay[offset]);
return mDisplay[offset].get();
}
bool AnimationFrameDiscardingQueue::IsFirstFrameFinished() const {
MOZ_ASSERT(mFirstFrame);
MOZ_ASSERT(mFirstFrame->IsFinished());
return true;
}
bool AnimationFrameDiscardingQueue::IsLastInsertedFrame(
imgFrame* aFrame) const {
return !mDisplay.empty() && mDisplay.back().get() == aFrame;
}
void AnimationFrameDiscardingQueue::AddSizeOfExcludingThis(
MallocSizeOf aMallocSizeOf, const AddSizeOfCb& aCallback) {
mFirstFrame->AddSizeOfExcludingThis(aMallocSizeOf,
[&](AddSizeOfCbData& aMetadata) {
aMetadata.mIndex = 1;
aCallback(aMetadata);
});
size_t i = mGetIndex;
for (const RefPtr<imgFrame>& frame : mDisplay) {
++i;
if (mSize < i) {
i = 1;
if (mFirstFrame.get() == frame.get()) {
// First frame again, we already covered it above. We can have a
// different frame in the first frame position in the discard queue
// on subsequent passes of the animation. This is useful for recycling.
continue;
}
}
frame->AddSizeOfExcludingThis(aMallocSizeOf,
[&](AddSizeOfCbData& aMetadata) {
aMetadata.mIndex = i;
aCallback(aMetadata);
});
}
}
AnimationFrameRecyclingQueue::AnimationFrameRecyclingQueue(
AnimationFrameRetainedBuffer&& aQueue)
: AnimationFrameDiscardingQueue(std::move(aQueue)),
mForceUseFirstFrameRefreshArea(false) {
// In an ideal world, we would always save the already displayed frames for
// recycling but none of the frames were marked as recyclable. We will incur
// the extra allocation cost for a few more frames.
mRecycling = true;
// Until we reach the end of the animation, set the first frame refresh area
// to match that of the full area of the first frame.
mFirstFrameRefreshArea = mFirstFrame->GetRect();
}
void AnimationFrameRecyclingQueue::AddSizeOfExcludingThis(
MallocSizeOf aMallocSizeOf, const AddSizeOfCb& aCallback) {
AnimationFrameDiscardingQueue::AddSizeOfExcludingThis(aMallocSizeOf,
aCallback);
for (const RecycleEntry& entry : mRecycle) {
if (entry.mFrame) {
entry.mFrame->AddSizeOfExcludingThis(
aMallocSizeOf, [&](AddSizeOfCbData& aMetadata) {
aMetadata.mIndex = 0; // Frame is not applicable
aCallback(aMetadata);
});
}
}
}
void AnimationFrameRecyclingQueue::AdvanceInternal() {
// We only want to change the current frame index if we have advanced. This
// means either a higher frame index, or going back to the beginning.
// We should never have advanced beyond the frame buffer.
MOZ_ASSERT(mGetIndex < mSize);
MOZ_ASSERT(!mDisplay.empty());
MOZ_ASSERT(mDisplay.front());
// We have advanced past the first frame. That means the next frame we are
// putting in the queue to recycling is the first frame in the animation,
// and we no longer need to worry about having looped around.
if (mGetIndex == 1) {
mForceUseFirstFrameRefreshArea = false;
}
RefPtr<imgFrame>& front = mDisplay.front();
RecycleEntry newEntry(mForceUseFirstFrameRefreshArea ? mFirstFrameRefreshArea
: front->GetDirtyRect());
// If we are allowed to recycle the frame, then we should save it before the
// base class's AdvanceInternal discards it.
newEntry.mFrame = std::move(front);
// Even if the frame itself isn't saved, we want the dirty rect to calculate
// the recycle rect for future recycled frames.
mRecycle.push_back(std::move(newEntry));
mDisplay.pop_front();
MOZ_ASSERT(!mDisplay.empty());
MOZ_ASSERT(mDisplay.front());
if (mDisplay.size() + mPending - 1 < mBatch) {
// If we have fewer frames than the batch size, then ask for more. If we
// do not have any pending, then we know that there is no active decoding.
//
// We limit the batch to avoid using the frame we just added to the queue.
// This gives other parts of the system time to switch to the new current
// frame, and maximize buffer reuse. In particular this is useful for
// WebRender which holds onto the previous frame for much longer.
size_t newPending = std::min(mPending + mBatch, mRecycle.size() - 1);
if (newPending == 0 && (mDisplay.size() <= 1 || mPending > 0)) {
// If we already have pending frames, then the decoder is active and we
// cannot go below one. If we are displaying the only frame we have, and
// there are none pending, then we must request at least one more frame to
// continue to animation, because we won't advance again without a new
// frame. This may cause us to skip recycling because the previous frame
// is still in use.
newPending = 1;
}
mPending = newPending;
}
}
bool AnimationFrameRecyclingQueue::ResetInternal() {
// We should save any display frames that we can to save on at least the
// allocation. The first frame refresh area is guaranteed to be the aggregate
// dirty rect or the entire frame, and so the bare minimum area we can
// recycle. We don't need to worry about updating the dirty rect for the
// existing mRecycle entries, because that will happen in RecycleFrame when
// we try to pull out a frame to redecode the first frame.
for (RefPtr<imgFrame>& frame : mDisplay) {
RecycleEntry newEntry(mFirstFrameRefreshArea);
newEntry.mFrame = std::move(frame);
mRecycle.push_back(std::move(newEntry));
}
return AnimationFrameDiscardingQueue::ResetInternal();
}
RawAccessFrameRef AnimationFrameRecyclingQueue::RecycleFrame(
gfx::IntRect& aRecycleRect) {
if (mInsertIndex == 0) {
// If we are recreating the first frame, then we actually have already
// precomputed aggregate of the dirty rects as the first frame refresh
// area. We know that all of the frames still in the recycling queue
// need to take into account the same dirty rect because they are also
// frames which cross the boundary.
//
// Note that this may actually shrink the dirty rect if we estimated it
// earlier with the full frame size and now we have the actual, more
// conservative aggregate for the animation.
for (RecycleEntry& entry : mRecycle) {
entry.mDirtyRect = mFirstFrameRefreshArea;
}
// Until we advance to the first frame again, any subsequent recycled
// frames should also use the first frame refresh area.
mForceUseFirstFrameRefreshArea = true;
}
if (mRecycle.empty()) {
return RawAccessFrameRef();
}
RawAccessFrameRef recycledFrame;
if (mRecycle.front().mFrame) {
recycledFrame = mRecycle.front().mFrame->RawAccessRef();
MOZ_ASSERT(recycledFrame);
mRecycle.pop_front();
if (mForceUseFirstFrameRefreshArea) {
// We are still crossing the loop boundary and cannot rely upon the dirty
// rects of entries in mDisplay to be representative. E.g. The first frame
// is probably has a full frame dirty rect.
aRecycleRect = mFirstFrameRefreshArea;
} else {
// Calculate the recycle rect for the recycled frame. This is the
// cumulative dirty rect of all of the frames ahead of us to be displayed,
// and to be used for recycling. Or in other words, the dirty rect between
// the recycled frame and the decoded frame which reuses the buffer.
//
// We know at this point that mRecycle contains either frames from the end
// of the animation with the first frame refresh area as the dirty rect
// (plus the first frame likewise) and frames with their actual dirty rect
// from the start. mDisplay should also only contain frames from the start
// of the animation onwards.
aRecycleRect.SetRect(0, 0, 0, 0);
for (const RefPtr<imgFrame>& frame : mDisplay) {
aRecycleRect = aRecycleRect.Union(frame->GetDirtyRect());
}
for (const RecycleEntry& entry : mRecycle) {
aRecycleRect = aRecycleRect.Union(entry.mDirtyRect);
}
}
} else {
mRecycle.pop_front();
}
return recycledFrame;
}
} // namespace image
} // namespace mozilla