/* * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com) * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" #include "BitmapImage.h" #include "FloatRect.h" #include "ImageObserver.h" #include "IntRect.h" #include "MIMETypeRegistry.h" #include "PlatformMemoryInstrumentation.h" #include "Timer.h" #include #include #include #include namespace WebCore { BitmapImage::BitmapImage(ImageObserver* observer) : Image(observer) , m_currentFrame(0) , m_frames(0) , m_frameTimer(0) , m_repetitionCount(cAnimationNone) , m_repetitionCountStatus(Unknown) , m_repetitionsComplete(0) , m_desiredFrameStartTime(0) , m_decodedSize(0) , m_decodedPropertiesSize(0) , m_frameCount(0) , m_isSolidColor(false) , m_checkedForSolidColor(false) , m_animationFinished(false) , m_allDataReceived(false) , m_haveSize(false) , m_sizeAvailable(false) , m_hasUniformFrameSize(true) , m_haveFrameCount(false) { } BitmapImage::~BitmapImage() { invalidatePlatformData(); stopAnimation(); } bool BitmapImage::isBitmapImage() const { return true; } bool BitmapImage::hasSingleSecurityOrigin() const { return true; } void BitmapImage::destroyDecodedData(bool destroyAll) { unsigned frameBytesCleared = 0; const size_t clearBeforeFrame = destroyAll ? m_frames.size() : m_currentFrame; for (size_t i = 0; i < clearBeforeFrame; ++i) { // The underlying frame isn't actually changing (we're just trying to // save the memory for the framebuffer data), so we don't need to clear // the metadata. unsigned frameBytes = m_frames[i].m_frameBytes; if (m_frames[i].clear(false)) frameBytesCleared += frameBytes; } destroyMetadataAndNotify(frameBytesCleared); m_source.clear(destroyAll, clearBeforeFrame, data(), m_allDataReceived); return; } void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll) { // Animated images >5MB are considered large enough that we'll only hang on // to one frame at a time. static const unsigned cLargeAnimationCutoff = 5242880; unsigned allFrameBytes = 0; for (size_t i = 0; i < m_frames.size(); ++i) allFrameBytes += m_frames[i].m_frameBytes; if (allFrameBytes > cLargeAnimationCutoff) destroyDecodedData(destroyAll); } void BitmapImage::destroyMetadataAndNotify(unsigned frameBytesCleared) { m_isSolidColor = false; m_checkedForSolidColor = false; invalidatePlatformData(); ASSERT(m_decodedSize >= frameBytesCleared); m_decodedSize -= frameBytesCleared; if (frameBytesCleared > 0) { frameBytesCleared += m_decodedPropertiesSize; m_decodedPropertiesSize = 0; } if (frameBytesCleared && imageObserver()) imageObserver()->decodedSizeChanged(this, -safeCast(frameBytesCleared)); } void BitmapImage::cacheFrame(size_t index) { size_t numFrames = frameCount(); ASSERT(m_decodedSize == 0 || numFrames > 1); if (m_frames.size() < numFrames) m_frames.grow(numFrames); m_frames[index].m_frame = m_source.createFrameAtIndex(index); if (numFrames == 1 && m_frames[index].m_frame) checkForSolidColor(); m_frames[index].m_orientation = m_source.orientationAtIndex(index); m_frames[index].m_haveMetadata = true; m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index); if (repetitionCount(false) != cAnimationNone) m_frames[index].m_duration = m_source.frameDurationAtIndex(index); m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index); m_frames[index].m_frameBytes = m_source.frameBytesAtIndex(index); const IntSize frameSize(index ? m_source.frameSizeAtIndex(index) : m_size); if (frameSize != m_size) m_hasUniformFrameSize = false; if (m_frames[index].m_frame) { int deltaBytes = safeCast(m_frames[index].m_frameBytes); m_decodedSize += deltaBytes; // The fully-decoded frame will subsume the partially decoded data used // to determine image properties. deltaBytes -= m_decodedPropertiesSize; m_decodedPropertiesSize = 0; if (imageObserver()) imageObserver()->decodedSizeChanged(this, deltaBytes); } } void BitmapImage::didDecodeProperties() const { if (m_decodedSize) return; size_t updatedSize = m_source.bytesDecodedToDetermineProperties(); if (m_decodedPropertiesSize == updatedSize) return; int deltaBytes = updatedSize - m_decodedPropertiesSize; #if !ASSERT_DISABLED bool overflow = updatedSize > m_decodedPropertiesSize && deltaBytes < 0; bool underflow = updatedSize < m_decodedPropertiesSize && deltaBytes > 0; ASSERT(!overflow && !underflow); #endif m_decodedPropertiesSize = updatedSize; if (imageObserver()) imageObserver()->decodedSizeChanged(this, deltaBytes); } void BitmapImage::updateSize() const { if (!m_sizeAvailable || m_haveSize) return; m_size = m_source.size(); m_sizeRespectingOrientation = m_source.size(RespectImageOrientation); m_haveSize = true; didDecodeProperties(); } IntSize BitmapImage::size() const { updateSize(); return m_size; } IntSize BitmapImage::sizeRespectingOrientation() const { updateSize(); return m_sizeRespectingOrientation; } IntSize BitmapImage::currentFrameSize() const { if (!m_currentFrame || m_hasUniformFrameSize) return size(); IntSize frameSize = m_source.frameSizeAtIndex(m_currentFrame); didDecodeProperties(); return frameSize; } bool BitmapImage::getHotSpot(IntPoint& hotSpot) const { bool result = m_source.getHotSpot(hotSpot); didDecodeProperties(); return result; } bool BitmapImage::dataChanged(bool allDataReceived) { // Clear all partially-decoded frames. For most image formats, there is only // one frame, but at least GIF and ICO can have more. With GIFs, the frames // come in order and we ask to decode them in order, waiting to request a // subsequent frame until the prior one is complete. Given that we clear // incomplete frames here, this means there is at most one incomplete frame // (even if we use destroyDecodedData() -- since it doesn't reset the // metadata), and it is after all the complete frames. // // With ICOs, on the other hand, we may ask for arbitrary frames at // different times (e.g. because we're displaying a higher-resolution image // in the content area and using a lower-resolution one for the favicon), // and the frames aren't even guaranteed to appear in the file in the same // order as in the directory, so an arbitrary number of the frames might be // incomplete (if we ask for frames for which we've not yet reached the // start of the frame data), and any or none of them might be the particular // frame affected by appending new data here. Thus we have to clear all the // incomplete frames to be safe. unsigned frameBytesCleared = 0; for (size_t i = 0; i < m_frames.size(); ++i) { // NOTE: Don't call frameIsCompleteAtIndex() here, that will try to // decode any uncached (i.e. never-decoded or // cleared-on-a-previous-pass) frames! unsigned frameBytes = m_frames[i].m_frameBytes; if (m_frames[i].m_haveMetadata && !m_frames[i].m_isComplete) frameBytesCleared += (m_frames[i].clear(true) ? frameBytes : 0); } destroyMetadataAndNotify(frameBytesCleared); // Feed all the data we've seen so far to the image decoder. m_allDataReceived = allDataReceived; m_source.setData(data(), allDataReceived); m_haveFrameCount = false; m_hasUniformFrameSize = true; return isSizeAvailable(); } String BitmapImage::filenameExtension() const { return m_source.filenameExtension(); } size_t BitmapImage::frameCount() { if (!m_haveFrameCount) { m_frameCount = m_source.frameCount(); // If decoder is not initialized yet, m_source.frameCount() returns 0. if (m_frameCount) { didDecodeProperties(); m_haveFrameCount = true; } } return m_frameCount; } bool BitmapImage::isSizeAvailable() { if (m_sizeAvailable) return true; m_sizeAvailable = m_source.isSizeAvailable(); didDecodeProperties(); return m_sizeAvailable; } bool BitmapImage::ensureFrameIsCached(size_t index) { if (index >= frameCount()) return false; if (index >= m_frames.size() || !m_frames[index].m_frame) cacheFrame(index); return true; } NativeImagePtr BitmapImage::frameAtIndex(size_t index) { if (!ensureFrameIsCached(index)) return 0; return m_frames[index].m_frame; } bool BitmapImage::frameIsCompleteAtIndex(size_t index) { if (!ensureFrameIsCached(index)) return false; return m_frames[index].m_isComplete; } float BitmapImage::frameDurationAtIndex(size_t index) { if (!ensureFrameIsCached(index)) return 0; return m_frames[index].m_duration; } NativeImagePtr BitmapImage::nativeImageForCurrentFrame() { return frameAtIndex(currentFrame()); } bool BitmapImage::frameHasAlphaAtIndex(size_t index) { if (m_frames.size() <= index) return true; if (m_frames[index].m_haveMetadata) return m_frames[index].m_hasAlpha; return m_source.frameHasAlphaAtIndex(index); } bool BitmapImage::currentFrameHasAlpha() { return frameHasAlphaAtIndex(currentFrame()); } ImageOrientation BitmapImage::currentFrameOrientation() { return frameOrientationAtIndex(currentFrame()); } ImageOrientation BitmapImage::frameOrientationAtIndex(size_t index) { if (m_frames.size() <= index) return DefaultImageOrientation; if (m_frames[index].m_haveMetadata) return m_frames[index].m_orientation; return m_source.orientationAtIndex(index); } #if !ASSERT_DISABLED bool BitmapImage::notSolidColor() { return size().width() != 1 || size().height() != 1 || frameCount() > 1; } #endif int BitmapImage::repetitionCount(bool imageKnownToBeComplete) { if ((m_repetitionCountStatus == Unknown) || ((m_repetitionCountStatus == Uncertain) && imageKnownToBeComplete)) { // Snag the repetition count. If |imageKnownToBeComplete| is false, the // repetition count may not be accurate yet for GIFs; in this case the // decoder will default to cAnimationLoopOnce, and we'll try and read // the count again once the whole image is decoded. m_repetitionCount = m_source.repetitionCount(); didDecodeProperties(); m_repetitionCountStatus = (imageKnownToBeComplete || m_repetitionCount == cAnimationNone) ? Certain : Uncertain; } return m_repetitionCount; } bool BitmapImage::shouldAnimate() { return (repetitionCount(false) != cAnimationNone && !m_animationFinished && imageObserver()); } void BitmapImage::startAnimation(bool catchUpIfNecessary) { if (m_frameTimer || !shouldAnimate() || frameCount() <= 1) return; // If we aren't already animating, set now as the animation start time. const double time = monotonicallyIncreasingTime(); if (!m_desiredFrameStartTime) m_desiredFrameStartTime = time; // Don't advance the animation to an incomplete frame. size_t nextFrame = (m_currentFrame + 1) % frameCount(); if (!m_allDataReceived && !frameIsCompleteAtIndex(nextFrame)) return; // Don't advance past the last frame if we haven't decoded the whole image // yet and our repetition count is potentially unset. The repetition count // in a GIF can potentially come after all the rest of the image data, so // wait on it. if (!m_allDataReceived && repetitionCount(false) == cAnimationLoopOnce && m_currentFrame >= (frameCount() - 1)) return; // Determine time for next frame to start. By ignoring paint and timer lag // in this calculation, we make the animation appear to run at its desired // rate regardless of how fast it's being repainted. const double currentDuration = frameDurationAtIndex(m_currentFrame); m_desiredFrameStartTime += currentDuration; // When an animated image is more than five minutes out of date, the // user probably doesn't care about resyncing and we could burn a lot of // time looping through frames below. Just reset the timings. const double cAnimationResyncCutoff = 5 * 60; if ((time - m_desiredFrameStartTime) > cAnimationResyncCutoff) m_desiredFrameStartTime = time + currentDuration; // The image may load more slowly than it's supposed to animate, so that by // the time we reach the end of the first repetition, we're well behind. // Clamp the desired frame start time in this case, so that we don't skip // frames (or whole iterations) trying to "catch up". This is a tradeoff: // It guarantees users see the whole animation the second time through and // don't miss any repetitions, and is closer to what other browsers do; on // the other hand, it makes animations "less accurate" for pages that try to // sync an image and some other resource (e.g. audio), especially if users // switch tabs (and thus stop drawing the animation, which will pause it) // during that initial loop, then switch back later. if (nextFrame == 0 && m_repetitionsComplete == 0 && m_desiredFrameStartTime < time) m_desiredFrameStartTime = time; if (!catchUpIfNecessary || time < m_desiredFrameStartTime) { // Haven't yet reached time for next frame to start; delay until then. m_frameTimer = new Timer(this, &BitmapImage::advanceAnimation); m_frameTimer->startOneShot(std::max(m_desiredFrameStartTime - time, 0.)); } else { // We've already reached or passed the time for the next frame to start. // See if we've also passed the time for frames after that to start, in // case we need to skip some frames entirely. Remember not to advance // to an incomplete frame. for (size_t frameAfterNext = (nextFrame + 1) % frameCount(); frameIsCompleteAtIndex(frameAfterNext); frameAfterNext = (nextFrame + 1) % frameCount()) { // Should we skip the next frame? double frameAfterNextStartTime = m_desiredFrameStartTime + frameDurationAtIndex(nextFrame); if (time < frameAfterNextStartTime) break; // Yes; skip over it without notifying our observers. if (!internalAdvanceAnimation(true)) return; m_desiredFrameStartTime = frameAfterNextStartTime; nextFrame = frameAfterNext; } // Draw the next frame immediately. Note that m_desiredFrameStartTime // may be in the past, meaning the next time through this function we'll // kick off the next advancement sooner than this frame's duration would // suggest. if (internalAdvanceAnimation(false)) { // The image region has been marked dirty, but once we return to our // caller, draw() will clear it, and nothing will cause the // animation to advance again. We need to start the timer for the // next frame running, or the animation can hang. (Compare this // with when advanceAnimation() is called, and the region is dirtied // while draw() is not in the callstack, meaning draw() gets called // to update the region and thus startAnimation() is reached again.) // NOTE: For large images with slow or heavily-loaded systems, // throwing away data as we go (see destroyDecodedData()) means we // can spend so much time re-decoding data above that by the time we // reach here we're behind again. If we let startAnimation() run // the catch-up code again, we can get long delays without painting // as we race the timer, or even infinite recursion. In this // situation the best we can do is to simply change frames as fast // as possible, so force startAnimation() to set a zero-delay timer // and bail out if we're not caught up. startAnimation(false); } } } void BitmapImage::stopAnimation() { // This timer is used to animate all occurrences of this image. Don't invalidate // the timer unless all renderers have stopped drawing. delete m_frameTimer; m_frameTimer = 0; } void BitmapImage::resetAnimation() { stopAnimation(); m_currentFrame = 0; m_repetitionsComplete = 0; m_desiredFrameStartTime = 0; m_animationFinished = false; // For extremely large animations, when the animation is reset, we just throw everything away. destroyDecodedDataIfNecessary(true); } unsigned BitmapImage::decodedSize() const { return m_decodedSize; } void BitmapImage::advanceAnimation(Timer*) { internalAdvanceAnimation(false); // At this point the image region has been marked dirty, and if it's // onscreen, we'll soon make a call to draw(), which will call // startAnimation() again to keep the animation moving. } bool BitmapImage::internalAdvanceAnimation(bool skippingFrames) { // Stop the animation. stopAnimation(); // See if anyone is still paying attention to this animation. If not, we don't // advance and will remain suspended at the current frame until the animation is resumed. if (!skippingFrames && imageObserver()->shouldPauseAnimation(this)) return false; ++m_currentFrame; bool advancedAnimation = true; bool destroyAll = false; if (m_currentFrame >= frameCount()) { ++m_repetitionsComplete; // Get the repetition count again. If we weren't able to get a // repetition count before, we should have decoded the whole image by // now, so it should now be available. // Note that we don't need to special-case cAnimationLoopOnce here // because it is 0 (see comments on its declaration in ImageSource.h). if (repetitionCount(true) != cAnimationLoopInfinite && m_repetitionsComplete > m_repetitionCount) { m_animationFinished = true; m_desiredFrameStartTime = 0; --m_currentFrame; advancedAnimation = false; } else { m_currentFrame = 0; destroyAll = true; } } destroyDecodedDataIfNecessary(destroyAll); // We need to draw this frame if we advanced to it while not skipping, or if // while trying to skip frames we hit the last frame and thus had to stop. if (skippingFrames != advancedAnimation) imageObserver()->animationAdvanced(this); return advancedAnimation; } bool BitmapImage::mayFillWithSolidColor() { if (!m_checkedForSolidColor && frameCount() > 0) { checkForSolidColor(); // WINCE PORT: checkForSolidColor() doesn't set m_checkedForSolidColor until // it gets enough information to make final decision. #if !OS(WINCE) ASSERT(m_checkedForSolidColor); #endif } return m_isSolidColor && !m_currentFrame; } Color BitmapImage::solidColor() const { return m_solidColor; } void BitmapImage::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const { MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image); Image::reportMemoryUsage(memoryObjectInfo); info.addMember(m_source); info.addMember(m_frameTimer); info.addMember(m_frames); } void FrameData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const { MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image); #if OS(WINCE) && !PLATFORM(QT) info.addRawBuffer(m_frame.get(), m_frameBytes); #elif USE(SKIA) info.addMember(m_frame); #else info.addRawBuffer(m_frame, m_frameBytes); #endif } }