diff options
Diffstat (limited to 'image/FrameAnimator.cpp')
| -rw-r--r-- | image/FrameAnimator.cpp | 887 |
1 files changed, 887 insertions, 0 deletions
diff --git a/image/FrameAnimator.cpp b/image/FrameAnimator.cpp new file mode 100644 index 0000000000..8c29b5636a --- /dev/null +++ b/image/FrameAnimator.cpp @@ -0,0 +1,887 @@ +/* -*- 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 "imgIContainer.h" +#include "LookupResult.h" +#include "MainThreadUtils.h" +#include "RasterImage.h" + +#include "pixman.h" + +namespace mozilla { + +using namespace gfx; + +namespace image { + +/////////////////////////////////////////////////////////////////////////////// +// AnimationState implementation. +/////////////////////////////////////////////////////////////////////////////// + +void +AnimationState::SetDoneDecoding(bool aDone) +{ + mDoneDecoding = aDone; +} + +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(!mDoneDecoding, "Adding new frames after decoding is finished?"); + MOZ_ASSERT(aFrameCount <= mFrameCount + 1, "Skipped a frame?"); + + mFrameCount = aFrameCount; +} + +Maybe<uint32_t> +AnimationState::FrameCount() const +{ + return mDoneDecoding ? 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(mDoneDecoding, "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) const +{ + TimeStamp currentFrameTime = aState.mCurrentAnimationFrameTime; + FrameTimeout timeout = GetTimeoutForFrame(aState.mCurrentAnimationFrameIndex); + + 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 TimeStamp::NowLoRes() + + TimeDuration::FromMilliseconds(31536000.0); + } + + TimeDuration durationOfTimeout = + TimeDuration::FromMilliseconds(double(timeout.AsMilliseconds())); + TimeStamp currentFrameEndTime = currentFrameTime + durationOfTimeout; + + return currentFrameEndTime; +} + +RefreshResult +FrameAnimator::AdvanceFrame(AnimationState& aState, TimeStamp aTime) +{ + NS_ASSERTION(aTime <= TimeStamp::Now(), + "Given time appears to be in the future"); + PROFILER_LABEL_FUNC(js::ProfileEntry::Category::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(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; + } + + if (GetTimeoutForFrame(nextFrameIndex) == FrameTimeout::Forever()) { + ret.mAnimationFinished = true; + } + + if (nextFrameIndex == 0) { + ret.mDirtyRect = aState.FirstFrameRefreshArea(); + } else { + MOZ_ASSERT(nextFrameIndex == currentFrameIndex + 1); + + // Change frame + if (!DoBlend(&ret.mDirtyRect, currentFrameIndex, nextFrameIndex)) { + // something went wrong, move on to next + NS_WARNING("FrameAnimator::AdvanceFrame(): Compositing of frame failed"); + nextFrame->SetCompositingFailed(true); + aState.mCurrentAnimationFrameTime = GetCurrentImgFrameEndTime(aState); + aState.mCurrentAnimationFrameIndex = nextFrameIndex; + + return ret; + } + + nextFrame->SetCompositingFailed(false); + } + + aState.mCurrentAnimationFrameTime = GetCurrentImgFrameEndTime(aState); + + // 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(). + FrameTimeout loopTime = aState.LoopLength(); + if (loopTime != FrameTimeout::Forever()) { + 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(); + aState.mCurrentAnimationFrameTime += + TimeDuration::FromMilliseconds(loops * loopTime.AsMilliseconds()); + } + } + + // 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) +{ + // only advance the frame if the current time is greater than or + // equal to the current frame's end time. + TimeStamp currentFrameEndTime = GetCurrentImgFrameEndTime(aState); + + // By default, an empty RefreshResult. + RefreshResult ret; + + while (currentFrameEndTime <= aTime) { + TimeStamp oldFrameEndTime = currentFrameEndTime; + + RefreshResult frameRes = AdvanceFrame(aState, aTime); + + // Accumulate our result for returning to callers. + ret.Accumulate(frameRes); + + currentFrameEndTime = GetCurrentImgFrameEndTime(aState); + + // 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; + } + } + + return ret; +} + +LookupResult +FrameAnimator::GetCompositedFrame(uint32_t aFrameNum) +{ + // If we have a composited version of this frame, return that. + if (mLastCompositedFrameIndex == int32_t(aFrameNum)) { + 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. + LookupResult result = + SurfaceCache::Lookup(ImageKey(mImage), + RasterSurfaceKey(mSize, + DefaultSurfaceFlags(), + PlaybackType::eAnimated)); + 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(aFrameNum))) { + return LookupResult(MatchType::NOT_FOUND); + } + + MOZ_ASSERT(!result.Surface()->GetIsPaletted(), + "About to return a paletted frame"); + + return result; +} + +FrameTimeout +FrameAnimator::GetTimeoutForFrame(uint32_t aFrameNum) const +{ + RawAccessFrameRef frame = GetRawFrame(aFrameNum); + if (frame) { + AnimationData data = frame->GetAnimationData(); + return data.mTimeout; + } + + NS_WARNING("No frame; called GetTimeoutForFrame too early?"); + return FrameTimeout::FromRawMilliseconds(100); +} + +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, aType); + + // Extract the surface's memory usage information. + size_t heap = 0, nonHeap = 0; + aSurface->AddSizeOfExcludingThis(aMallocSizeOf, heap, nonHeap); + counter.Values().SetDecodedHeap(heap); + counter.Values().SetDecodedNonHeap(nonHeap); + + // 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(uint32_t aFrameNum) const +{ + LookupResult result = + SurfaceCache::Lookup(ImageKey(mImage), + RasterSurfaceKey(mSize, + DefaultSurfaceFlags(), + PlaybackType::eAnimated)); + if (!result) { + return RawAccessFrameRef(); + } + + // 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(result.Surface().Seek(aFrameNum))) { + return RawAccessFrameRef(); // Not available yet. + } + + return result.Surface()->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(IntRect* aDirtyRect, + uint32_t aPrevFrameIndex, + uint32_t aNextFrameIndex) +{ + RawAccessFrameRef prevFrame = GetRawFrame(aPrevFrameIndex); + RawAccessFrameRef nextFrame = GetRawFrame(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.x == 0 && prevRect.y == 0 && + prevRect.width == mSize.width && + prevRect.height == 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.x == 0 && nextRect.y == 0 && + nextRect.width == mSize.width && + nextRect.height == 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->InitForDecoder(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.x + prevRect.width <= nextRect.x + nextRect.width) && + (prevRect.y + prevRect.height <= nextRect.y + nextRect.height)) { + // 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->InitForDecoder(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.y + toClear.height; ++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 |