The Tor Browser: image/src/FrameAnimator.cpp@6474c204b198 (annotated)

image/src/FrameAnimator.cpp@6474c204b198 (annotated)

image/src/FrameAnimator.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 / annotate

image/src/FrameAnimator.cpp@6474c204b198 (annotated)

image/src/FrameAnimator.cpp