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 "AnimationSurfaceProvider.h"
#include "mozilla/StaticPrefs_image.h"
#include "mozilla/gfx/gfxVars.h"
#include "mozilla/layers/SharedSurfacesChild.h"
#include "mozilla/layers/SourceSurfaceSharedData.h"
#include "nsProxyRelease.h"
#include "DecodePool.h"
#include "Decoder.h"
using namespace mozilla::gfx;
using namespace mozilla::layers;
namespace mozilla {
namespace image {
AnimationSurfaceProvider::AnimationSurfaceProvider(
NotNull<RasterImage*> aImage, const SurfaceKey& aSurfaceKey,
NotNull<Decoder*> aDecoder, size_t aCurrentFrame)
: ISurfaceProvider(ImageKey(aImage.get()), aSurfaceKey,
AvailabilityState::StartAsPlaceholder()),
mImage(aImage.get()),
mDecodingMutex("AnimationSurfaceProvider::mDecoder"),
mDecoder(aDecoder.get()),
mFramesMutex("AnimationSurfaceProvider::mFrames"),
mCompositedFrameRequested(false),
mSharedAnimation(MakeRefPtr<SharedSurfacesAnimation>()) {
MOZ_ASSERT(!mDecoder->IsMetadataDecode(),
"Use MetadataDecodingTask for metadata decodes");
MOZ_ASSERT(!mDecoder->IsFirstFrameDecode(),
"Use DecodedSurfaceProvider for single-frame image decodes");
// Calculate how many frames we need to decode in this animation before we
// enter decode-on-demand mode.
IntSize frameSize = aSurfaceKey.Size();
size_t threshold =
(size_t(StaticPrefs::image_animated_decode_on_demand_threshold_kb()) *
1024) /
(sizeof(uint32_t) * frameSize.width * frameSize.height);
size_t batch = StaticPrefs::image_animated_decode_on_demand_batch_size();
mFrames.reset(
new AnimationFrameRetainedBuffer(threshold, batch, aCurrentFrame));
}
AnimationSurfaceProvider::~AnimationSurfaceProvider() {
DropImageReference();
mSharedAnimation->Destroy();
if (mDecoder) {
mDecoder->SetFrameRecycler(nullptr);
}
}
void AnimationSurfaceProvider::DropImageReference() {
if (!mImage) {
return; // Nothing to do.
}
// RasterImage objects need to be destroyed on the main thread.
SurfaceCache::ReleaseImageOnMainThread(mImage.forget());
}
void AnimationSurfaceProvider::Reset() {
// We want to go back to the beginning.
bool mayDiscard;
bool restartDecoder = false;
{
MutexAutoLock lock(mFramesMutex);
// If we have not crossed the threshold, we know we haven't discarded any
// frames, and thus we know it is safe move our display index back to the
// very beginning. It would be cleaner to let the frame buffer make this
// decision inside the AnimationFrameBuffer::Reset method, but if we have
// crossed the threshold, we need to hold onto the decoding mutex too. We
// should avoid blocking the main thread on the decoder threads.
mayDiscard = mFrames->MayDiscard();
if (!mayDiscard) {
restartDecoder = mFrames->Reset();
}
}
if (mayDiscard) {
// We are over the threshold and have started discarding old frames. In
// that case we need to seize the decoding mutex. Thankfully we know that
// we are in the process of decoding at most the batch size frames, so
// this should not take too long to acquire.
MutexAutoLock lock(mDecodingMutex);
// We may have hit an error while redecoding. Because FrameAnimator is
// tightly coupled to our own state, that means we would need to go through
// some heroics to resume animating in those cases. The typical reason for
// a redecode to fail is out of memory, and recycling should prevent most of
// those errors. When image.animated.generate-full-frames has shipped
// enabled on a release or two, we can simply remove the old FrameAnimator
// blending code and simplify this quite a bit -- just always pop the next
// full frame and timeout off the stack.
if (mDecoder) {
mDecoder = DecoderFactory::CloneAnimationDecoder(mDecoder);
MOZ_ASSERT(mDecoder);
MutexAutoLock lock2(mFramesMutex);
restartDecoder = mFrames->Reset();
} else {
MOZ_ASSERT(mFrames->HasRedecodeError());
}
}
if (restartDecoder) {
DecodePool::Singleton()->AsyncRun(this);
}
}
void AnimationSurfaceProvider::Advance(size_t aFrame) {
bool restartDecoder;
RefPtr<SourceSurface> surface;
IntRect dirtyRect;
{
// Typical advancement of a frame.
MutexAutoLock lock(mFramesMutex);
restartDecoder = mFrames->AdvanceTo(aFrame);
imgFrame* frame = mFrames->Get(aFrame, /* aForDisplay */ true);
MOZ_ASSERT(frame);
if (aFrame != 0) {
dirtyRect = frame->GetDirtyRect();
} else {
MOZ_ASSERT(mFrames->SizeKnown());
dirtyRect = mFrames->FirstFrameRefreshArea();
}
surface = frame->GetSourceSurface();
MOZ_ASSERT(surface);
}
if (restartDecoder) {
DecodePool::Singleton()->AsyncRun(this);
}
mCompositedFrameRequested = false;
auto* sharedSurface = static_cast<SourceSurfaceSharedData*>(surface.get());
mSharedAnimation->SetCurrentFrame(sharedSurface, dirtyRect);
}
DrawableFrameRef AnimationSurfaceProvider::DrawableRef(size_t aFrame) {
MutexAutoLock lock(mFramesMutex);
if (Availability().IsPlaceholder()) {
MOZ_ASSERT_UNREACHABLE("Calling DrawableRef() on a placeholder");
return DrawableFrameRef();
}
imgFrame* frame = mFrames->Get(aFrame, /* aForDisplay */ true);
if (!frame) {
return DrawableFrameRef();
}
return frame->DrawableRef();
}
already_AddRefed<imgFrame> AnimationSurfaceProvider::GetFrame(size_t aFrame) {
MutexAutoLock lock(mFramesMutex);
if (Availability().IsPlaceholder()) {
MOZ_ASSERT_UNREACHABLE("Calling GetFrame() on a placeholder");
return nullptr;
}
RefPtr<imgFrame> frame = mFrames->Get(aFrame, /* aForDisplay */ false);
MOZ_ASSERT_IF(frame, frame->IsFinished());
return frame.forget();
}
bool AnimationSurfaceProvider::IsFinished() const {
MutexAutoLock lock(mFramesMutex);
if (Availability().IsPlaceholder()) {
MOZ_ASSERT_UNREACHABLE("Calling IsFinished() on a placeholder");
return false;
}
return mFrames->IsFirstFrameFinished();
}
bool AnimationSurfaceProvider::IsFullyDecoded() const {
MutexAutoLock lock(mFramesMutex);
return mFrames->SizeKnown() && !mFrames->MayDiscard();
}
size_t AnimationSurfaceProvider::LogicalSizeInBytes() const {
// When decoding animated images, we need at most three live surfaces: the
// composited surface, the previous composited surface for
// DisposalMethod::RESTORE_PREVIOUS, and the surface we're currently decoding
// into. The composited surfaces are always BGRA. Although the surface we're
// decoding into may be paletted, and may be smaller than the real size of the
// image, we assume the worst case here.
// XXX(seth): Note that this is actually not accurate yet; we're storing the
// full sequence of frames, not just the three live surfaces mentioned above.
// Unfortunately there's no way to know in advance how many frames an
// animation has, so we really can't do better here. This will become correct
// once bug 1289954 is complete.
IntSize size = GetSurfaceKey().Size();
return 3 * size.width * size.height * sizeof(uint32_t);
}
void AnimationSurfaceProvider::AddSizeOfExcludingThis(
MallocSizeOf aMallocSizeOf, const AddSizeOfCb& aCallback) {
// Note that the surface cache lock is already held here, and then we acquire
// mFramesMutex. For this method, this ordering is unavoidable, which means
// that we must be careful to always use the same ordering elsewhere.
MutexAutoLock lock(mFramesMutex);
mFrames->AddSizeOfExcludingThis(aMallocSizeOf, aCallback);
}
void AnimationSurfaceProvider::Run() {
MutexAutoLock lock(mDecodingMutex);
if (!mDecoder) {
MOZ_ASSERT_UNREACHABLE("Running after decoding finished?");
return;
}
while (true) {
// Run the decoder.
LexerResult result = mDecoder->Decode(WrapNotNull(this));
if (result.is<TerminalState>()) {
// We may have a new frame now, but it's not guaranteed - a decoding
// failure or truncated data may mean that no new frame got produced.
// Since we're not sure, rather than call CheckForNewFrameAtYield() here
// we call CheckForNewFrameAtTerminalState(), which handles both of these
// possibilities.
bool continueDecoding = CheckForNewFrameAtTerminalState();
FinishDecoding();
// Even if it is the last frame, we may not have enough frames buffered
// ahead of the current. If we are shutting down, we want to ensure we
// release the thread as soon as possible. The animation may advance even
// during shutdown, which keeps us decoding, and thus blocking the decode
// pool during teardown.
if (!mDecoder || !continueDecoding ||
DecodePool::Singleton()->IsShuttingDown()) {
return;
}
// Restart from the very beginning because the decoder was recreated.
continue;
}
// If there is output available we want to change the entry in the surface
// cache from a placeholder to an actual surface now before NotifyProgress
// call below so that when consumers get the frame complete notification
// from the NotifyProgress they can actually get a surface from the surface
// cache.
bool checkForNewFrameAtYieldResult = false;
if (result == LexerResult(Yield::OUTPUT_AVAILABLE)) {
checkForNewFrameAtYieldResult = CheckForNewFrameAtYield();
}
// Notify for the progress we've made so far.
if (mImage && mDecoder->HasProgress()) {
NotifyProgress(WrapNotNull(mImage), WrapNotNull(mDecoder));
}
if (result == LexerResult(Yield::NEED_MORE_DATA)) {
// We can't make any more progress right now. The decoder itself will
// ensure that we get reenqueued when more data is available; just return
// for now.
return;
}
// There's new output available - a new frame! Grab it. If we don't need any
// more for the moment we can break out of the loop. If we are shutting
// down, we want to ensure we release the thread as soon as possible. The
// animation may advance even during shutdown, which keeps us decoding, and
// thus blocking the decode pool during teardown.
MOZ_ASSERT(result == LexerResult(Yield::OUTPUT_AVAILABLE));
if (!checkForNewFrameAtYieldResult ||
DecodePool::Singleton()->IsShuttingDown()) {
return;
}
}
}
bool AnimationSurfaceProvider::CheckForNewFrameAtYield() {
mDecodingMutex.AssertCurrentThreadOwns();
MOZ_ASSERT(mDecoder);
bool justGotFirstFrame = false;
bool continueDecoding = false;
{
MutexAutoLock lock(mFramesMutex);
// Try to get the new frame from the decoder.
RefPtr<imgFrame> frame = mDecoder->GetCurrentFrame();
MOZ_ASSERT(mDecoder->HasFrameToTake());
mDecoder->ClearHasFrameToTake();
if (!frame) {
MOZ_ASSERT_UNREACHABLE("Decoder yielded but didn't produce a frame?");
return true;
}
// We should've gotten a different frame than last time.
MOZ_ASSERT(!mFrames->IsLastInsertedFrame(frame));
// Append the new frame to the list.
AnimationFrameBuffer::InsertStatus status =
mFrames->Insert(std::move(frame));
// If we hit a redecode error, then we actually want to stop. This happens
// when we tried to insert more frames than we originally had (e.g. the
// original decoder attempt hit an OOM error sooner than we did). Better to
// stop the animation than to get out of sync with FrameAnimator.
if (mFrames->HasRedecodeError()) {
mDecoder = nullptr;
return false;
}
switch (status) {
case AnimationFrameBuffer::InsertStatus::DISCARD_CONTINUE:
continueDecoding = true;
[[fallthrough]];
case AnimationFrameBuffer::InsertStatus::DISCARD_YIELD:
RequestFrameDiscarding();
break;
case AnimationFrameBuffer::InsertStatus::CONTINUE:
continueDecoding = true;
break;
case AnimationFrameBuffer::InsertStatus::YIELD:
break;
default:
MOZ_ASSERT_UNREACHABLE("Unhandled insert status!");
break;
}
// We only want to handle the first frame if it is the first pass for the
// animation decoder. The owning image will be cleared after that.
size_t frameCount = mFrames->Size();
if (frameCount == 1 && mImage) {
justGotFirstFrame = true;
}
}
if (justGotFirstFrame) {
AnnounceSurfaceAvailable();
}
return continueDecoding;
}
bool AnimationSurfaceProvider::CheckForNewFrameAtTerminalState() {
mDecodingMutex.AssertCurrentThreadOwns();
MOZ_ASSERT(mDecoder);
bool justGotFirstFrame = false;
bool continueDecoding;
{
MutexAutoLock lock(mFramesMutex);
// The decoder may or may not have a new frame for us at this point. Avoid
// reinserting the same frame again.
RefPtr<imgFrame> frame = mDecoder->GetCurrentFrame();
// If the decoder didn't finish a new frame (ie if, after starting the
// frame, it got an error and aborted the frame and the rest of the decode)
// that means it won't be reporting it to the image or FrameAnimator so we
// should ignore it too, that's what HasFrameToTake tracks basically.
if (!mDecoder->HasFrameToTake()) {
frame = nullptr;
} else {
MOZ_ASSERT(frame);
mDecoder->ClearHasFrameToTake();
}
if (!frame || mFrames->IsLastInsertedFrame(frame)) {
return mFrames->MarkComplete(mDecoder->GetFirstFrameRefreshArea());
}
// Append the new frame to the list.
AnimationFrameBuffer::InsertStatus status =
mFrames->Insert(std::move(frame));
// If we hit a redecode error, then we actually want to stop. This will be
// fully handled in FinishDecoding.
if (mFrames->HasRedecodeError()) {
return false;
}
switch (status) {
case AnimationFrameBuffer::InsertStatus::DISCARD_CONTINUE:
case AnimationFrameBuffer::InsertStatus::DISCARD_YIELD:
RequestFrameDiscarding();
break;
case AnimationFrameBuffer::InsertStatus::CONTINUE:
case AnimationFrameBuffer::InsertStatus::YIELD:
break;
default:
MOZ_ASSERT_UNREACHABLE("Unhandled insert status!");
break;
}
continueDecoding =
mFrames->MarkComplete(mDecoder->GetFirstFrameRefreshArea());
// We only want to handle the first frame if it is the first pass for the
// animation decoder. The owning image will be cleared after that.
if (mFrames->Size() == 1 && mImage) {
justGotFirstFrame = true;
}
}
if (justGotFirstFrame) {
AnnounceSurfaceAvailable();
}
return continueDecoding;
}
void AnimationSurfaceProvider::RequestFrameDiscarding() {
mDecodingMutex.AssertCurrentThreadOwns();
mFramesMutex.AssertCurrentThreadOwns();
MOZ_ASSERT(mDecoder);
if (mFrames->MayDiscard() || mFrames->IsRecycling()) {
MOZ_ASSERT_UNREACHABLE("Already replaced frame queue!");
return;
}
auto oldFrameQueue =
static_cast<AnimationFrameRetainedBuffer*>(mFrames.get());
MOZ_ASSERT(!mDecoder->GetFrameRecycler());
if (StaticPrefs::image_animated_decode_on_demand_recycle_AtStartup()) {
mFrames.reset(new AnimationFrameRecyclingQueue(std::move(*oldFrameQueue)));
mDecoder->SetFrameRecycler(this);
} else {
mFrames.reset(new AnimationFrameDiscardingQueue(std::move(*oldFrameQueue)));
}
}
void AnimationSurfaceProvider::AnnounceSurfaceAvailable() {
mFramesMutex.AssertNotCurrentThreadOwns();
MOZ_ASSERT(mImage);
// We just got the first frame; let the surface cache know. We deliberately do
// this outside of mFramesMutex to avoid a potential deadlock with
// AddSizeOfExcludingThis(), since otherwise we'd be acquiring mFramesMutex
// and then the surface cache lock, while the memory reporting code would
// acquire the surface cache lock and then mFramesMutex.
SurfaceCache::SurfaceAvailable(WrapNotNull(this));
}
void AnimationSurfaceProvider::FinishDecoding() {
mDecodingMutex.AssertCurrentThreadOwns();
MOZ_ASSERT(mDecoder);
if (mImage) {
// Send notifications.
NotifyDecodeComplete(WrapNotNull(mImage), WrapNotNull(mDecoder));
}
// Determine if we need to recreate the decoder, in case we are discarding
// frames and need to loop back to the beginning.
bool recreateDecoder;
{
MutexAutoLock lock(mFramesMutex);
recreateDecoder = !mFrames->HasRedecodeError() && mFrames->MayDiscard();
}
if (recreateDecoder) {
mDecoder = DecoderFactory::CloneAnimationDecoder(mDecoder);
MOZ_ASSERT(mDecoder);
} else {
mDecoder = nullptr;
}
// We don't need a reference to our image anymore, either, and we don't want
// one. We may be stored in the surface cache for a long time after decoding
// finishes. If we don't drop our reference to the image, we'll end up
// keeping it alive as long as we remain in the surface cache, which could
// greatly extend the image's lifetime - in fact, if the image isn't
// discardable, it'd result in a leak!
DropImageReference();
}
bool AnimationSurfaceProvider::ShouldPreferSyncRun() const {
MutexAutoLock lock(mDecodingMutex);
MOZ_ASSERT(mDecoder);
return mDecoder->ShouldSyncDecode(
StaticPrefs::image_mem_decode_bytes_at_a_time_AtStartup());
}
RawAccessFrameRef AnimationSurfaceProvider::RecycleFrame(
gfx::IntRect& aRecycleRect) {
MutexAutoLock lock(mFramesMutex);
MOZ_ASSERT(mFrames->IsRecycling());
return mFrames->RecycleFrame(aRecycleRect);
}
nsresult AnimationSurfaceProvider::UpdateKey(
layers::RenderRootStateManager* aManager,
wr::IpcResourceUpdateQueue& aResources, wr::ImageKey& aKey) {
MOZ_ASSERT(NS_IsMainThread());
RefPtr<SourceSurface> surface;
{
MutexAutoLock lock(mFramesMutex);
imgFrame* frame =
mFrames->Get(mFrames->Displayed(), /* aForDisplay */ true);
if (!frame) {
return NS_ERROR_NOT_AVAILABLE;
}
surface = frame->GetSourceSurface();
}
mCompositedFrameRequested = true;
auto* sharedSurface = static_cast<SourceSurfaceSharedData*>(surface.get());
return mSharedAnimation->UpdateKey(sharedSurface, aManager, aResources, aKey);
}
} // namespace image
} // namespace mozilla