image/AnimationFrameBuffer.cpp
author Andrew Osmond <aosmond@mozilla.com>
Mon, 26 Nov 2018 07:30:50 -0500
changeset 448488 c36ca97de3d05dd769986a1ce315c1a4ed9a7f12
parent 447457 ccfa531dea0301244c99db4ff26d5610382487e2
child 448947 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1509408 - Fix animated image distortion regressions caused by frame recycling. r=tnikkel When bug 1508393 landed, it not only enabled producing of full frames on the decoder threads, it also enabled recycling of old animated image frame buffers it would have otherwise discarded. It reuses the contents of the buffer where possible given we know what pixels changed between the old frame and the frame we want to produce. However where this calculation was done was incorrect. We originally calculated it when we advanced the frame, but at that point there is no guarantee that we have all of the necessary information; we may have fallen behind on decoding. As such, we move the calculation to where we actually perform the recycling. At this point we are guaranteed to have all the necessary frames between the recycling and display queues. Differential Revision: https://phabricator.services.mozilla.com/D12903

/* -*- 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 "mozilla/Move.h"             // 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);

  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);
  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.index = i;
        aCallback(aMetadata);
      }
    );
  }
}

AnimationFrameDiscardingQueue::AnimationFrameDiscardingQueue(AnimationFrameRetainedBuffer&& aQueue)
  : AnimationFrameBuffer(aQueue)
  , mInsertIndex(aQueue.mFrames.Length())
  , mFirstFrame(std::move(aQueue.mFrames[0]))
{
  MOZ_ASSERT(!mSizeKnown);
  MOZ_ASSERT(!mRedecodeError);
  MOZ_ASSERT(mInsertIndex > 0);
  MOZ_ASSERT(mGetIndex > 0);
  mMayDiscard = true;

  for (size_t i = aQueue.mGetIndex; i < mInsertIndex; ++i) {
    MOZ_ASSERT(aQueue.mFrames[i]);
    mDisplay.push_back(std::move(aQueue.mFrames[i]));
  }
}

bool
AnimationFrameDiscardingQueue::InsertInternal(RefPtr<imgFrame>&& aFrame)
{
  // 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)) {
    MOZ_ASSERT(mSizeKnown);
    mRedecodeError = true;
    mPending = 0;
  }

  // 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.index = 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.index = 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;
}

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.index = 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.
  if (front->ShouldRecycle()) {
    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()
{
  mRecycle.clear();
  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.
    MOZ_ASSERT(mSizeKnown);
    MOZ_ASSERT(!mFirstFrameRefreshArea.IsEmpty());
    for (RecycleEntry& entry : mRecycle) {
      MOZ_ASSERT(mFirstFrameRefreshArea.Contains(entry.mDirtyRect));
      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;
}

bool
AnimationFrameRecyclingQueue::MarkComplete(const gfx::IntRect& aFirstFrameRefreshArea)
{
  bool continueDecoding =
    AnimationFrameDiscardingQueue::MarkComplete(aFirstFrameRefreshArea);

  MOZ_ASSERT_IF(!mRedecodeError,
                mFirstFrameRefreshArea.IsEmpty() ||
                mFirstFrameRefreshArea.IsEqualEdges(aFirstFrameRefreshArea));

  mFirstFrameRefreshArea = aFirstFrameRefreshArea;
  return continueDecoding;
}

} // namespace image
} // namespace mozilla