The Tor Browser: comparison image/src/FrameAnimator.cpp

--1:000000000000
+:dab7c7ef9ce5
+/* -*- 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 "FrameBlender.h"
+#include "imgIContainer.h"
+using namespace mozilla::image;
+using namespace mozilla;
+FrameAnimator::FrameAnimator(FrameBlender& aFrameBlender,
+uint16_t aAnimationMode)
+: mCurrentAnimationFrameIndex(0)
+, mLoopCounter(-1)
+, mFrameBlender(aFrameBlender)
+, mAnimationMode(aAnimationMode)
+, mDoneDecoding(false)
+{
+}
+int32_t
+FrameAnimator::GetSingleLoopTime() const
+{
+// If we aren't done decoding, we don't know the image's full play time.
+if (!mDoneDecoding) {
+return -1;
+}
+// If we're not looping, a single loop time has no meaning
+if (mAnimationMode != imgIContainer::kNormalAnimMode) {
+return -1;
+}
+uint32_t looptime = 0;
+for (uint32_t i = 0; i < mFrameBlender.GetNumFrames(); ++i) {
+int32_t timeout = mFrameBlender.GetTimeoutForFrame(i);
+if (timeout >= 0) {
+looptime += static_cast<uint32_t>(timeout);
+} else {
+// If we have a frame that never times out, we're probably in an error
+// case, but let's handle it more gracefully.
+NS_WARNING("Negative frame timeout - how did this happen?");
+return -1;
+}
+}
+return looptime;
+}
+TimeStamp
+FrameAnimator::GetCurrentImgFrameEndTime() const
+{
+TimeStamp currentFrameTime = mCurrentAnimationFrameTime;
+int32_t timeout = mFrameBlender.GetTimeoutForFrame(mCurrentAnimationFrameIndex);
+if (timeout < 0) {
+// We need to return a sentinel value in this case, because our logic
+// doesn't work correctly if we have a negative timeout value. 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
+// negative timeouts.
+return TimeStamp::NowLoRes() +
+TimeDuration::FromMilliseconds(31536000.0);
+}
+TimeDuration durationOfTimeout =
+TimeDuration::FromMilliseconds(static_cast<double>(timeout));
+TimeStamp currentFrameEndTime = currentFrameTime + durationOfTimeout;
+return currentFrameEndTime;
+}
+FrameAnimator::RefreshResult
+FrameAnimator::AdvanceFrame(TimeStamp aTime)
+{
+NS_ASSERTION(aTime <= TimeStamp::Now(),
+"Given time appears to be in the future");
+uint32_t currentFrameIndex = mCurrentAnimationFrameIndex;
+uint32_t nextFrameIndex = currentFrameIndex + 1;
+int32_t timeout = 0;
+RefreshResult ret;
+// If we're done decoding, we know we've got everything we're going to get.
+// If we aren't, we only display fully-downloaded frames; everything else
+// gets delayed.
+bool canDisplay = mDoneDecoding ||
+(mFrameBlender.RawGetFrame(nextFrameIndex) &&
+mFrameBlender.RawGetFrame(nextFrameIndex)->ImageComplete());
+if (!canDisplay) {
+// 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 we're done decoding the next frame, go ahead and display it now and
+// reinit with the next frame's delay time.
+if (mFrameBlender.GetNumFrames() == nextFrameIndex) {
+// End of an animation loop...
+// If we are not looping forever, initialize the loop counter
+if (mLoopCounter < 0 && mFrameBlender.GetLoopCount() >= 0) {
+mLoopCounter = mFrameBlender.GetLoopCount();
+}
+// If animation mode is "loop once", or we're at end of loop counter, it's time to stop animating
+if (mAnimationMode == imgIContainer::kLoopOnceAnimMode || mLoopCounter == 0) {
+ret.animationFinished = true;
+}
+nextFrameIndex = 0;
+if (mLoopCounter > 0) {
+mLoopCounter--;
+}
+// If we're done, exit early.
+if (ret.animationFinished) {
+return ret;
+}
+}
+timeout = mFrameBlender.GetTimeoutForFrame(nextFrameIndex);
+// Bad data
+if (timeout < 0) {
+ret.animationFinished = true;
+ret.error = true;
+}
+if (nextFrameIndex == 0) {
+ret.dirtyRect = mFirstFrameRefreshArea;
+} else {
+// Change frame
+if (!mFrameBlender.DoBlend(&ret.dirtyRect, currentFrameIndex, nextFrameIndex)) {
+// something went wrong, move on to next
+NS_WARNING("FrameAnimator::AdvanceFrame(): Compositing of frame failed");
+mFrameBlender.RawGetFrame(nextFrameIndex)->SetCompositingFailed(true);
+mCurrentAnimationFrameTime = GetCurrentImgFrameEndTime();
+mCurrentAnimationFrameIndex = nextFrameIndex;
+ret.error = true;
+return ret;
+}
+mFrameBlender.RawGetFrame(nextFrameIndex)->SetCompositingFailed(false);
+}
+mCurrentAnimationFrameTime = GetCurrentImgFrameEndTime();
+// If we can get closer to the current time by a multiple of the image's loop
+// time, we should.
+uint32_t loopTime = GetSingleLoopTime();
+if (loopTime > 0) {
+TimeDuration delay = aTime - mCurrentAnimationFrameTime;
+if (delay.ToMilliseconds() > loopTime) {
+// Explicitly use integer division to get the floor of the number of
+// loops.
+uint32_t loops = static_cast<uint32_t>(delay.ToMilliseconds()) / loopTime;
+mCurrentAnimationFrameTime += TimeDuration::FromMilliseconds(loops * loopTime);
+}
+}
+// Set currentAnimationFrameIndex at the last possible moment
+mCurrentAnimationFrameIndex = nextFrameIndex;
+// If we're here, we successfully advanced the frame.
+ret.frameAdvanced = true;
+return ret;
+}
+FrameAnimator::RefreshResult
+FrameAnimator::RequestRefresh(const mozilla::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();
+// By default, an empty RefreshResult.
+RefreshResult ret;
+while (currentFrameEndTime <= aTime) {
+TimeStamp oldFrameEndTime = currentFrameEndTime;
+RefreshResult frameRes = AdvanceFrame(aTime);
+// Accumulate our result for returning to callers.
+ret.Accumulate(frameRes);
+currentFrameEndTime = GetCurrentImgFrameEndTime();
+// 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.frameAdvanced && (currentFrameEndTime == oldFrameEndTime)) {
+break;
+}
+}
+return ret;
+}
+void
+FrameAnimator::ResetAnimation()
+{
+mCurrentAnimationFrameIndex = 0;
+}
+void
+FrameAnimator::SetDoneDecoding(bool aDone)
+{
+mDoneDecoding = aDone;
+}
+void
+FrameAnimator::SetAnimationMode(uint16_t aAnimationMode)
+{
+mAnimationMode = aAnimationMode;
+}
+void
+FrameAnimator::InitAnimationFrameTimeIfNecessary()
+{
+if (mCurrentAnimationFrameTime.IsNull()) {
+mCurrentAnimationFrameTime = TimeStamp::Now();
+}
+}
+void
+FrameAnimator::SetAnimationFrameTime(const TimeStamp& aTime)
+{
+mCurrentAnimationFrameTime = aTime;
+}
+void
+FrameAnimator::SetFirstFrameRefreshArea(const nsIntRect& aRect)
+{
+mFirstFrameRefreshArea = aRect;
+}
+void
+FrameAnimator::UnionFirstFrameRefreshArea(const nsIntRect& aRect)
+{
+mFirstFrameRefreshArea.UnionRect(mFirstFrameRefreshArea, aRect);
+}
+uint32_t
+FrameAnimator::GetCurrentAnimationFrameIndex() const
+{
+return mCurrentAnimationFrameIndex;
+}
+nsIntRect
+FrameAnimator::GetFirstFrameRefreshArea() const
+{
+return mFirstFrameRefreshArea;
+}

The Tor Browser / file comparison

comparison: image/src/FrameAnimator.cpp

image/src/FrameAnimator.cpp