Decode GIF image frames on demand.

Source/core/platform/image-decoders/ImageDecoder.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. 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
@@ skipping 97 matching lines @@
         // FrameData::clear()).
         PassNativeImagePtr asNewNativeImage() const;
 
         bool hasAlpha() const;
         const IntRect& originalFrameRect() const { return m_originalFrameRect; }
         FrameStatus status() const { return m_status; }
         unsigned duration() const { return m_duration; }
         FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
         bool premultiplyAlpha() const { return m_premultiplyAlpha; }
         void reportMemoryUsage(MemoryObjectInfo*) const;
+        size_t requiredPreviousFrameIndex() const
+        {
+            ASSERT(m_requiredPreviousFrameIndexValid);
+            return m_requiredPreviousFrameIndex;
+        }
 
         void setHasAlpha(bool alpha);
         void setOriginalFrameRect(const IntRect& r) { m_originalFrameRect = r; }
         void setStatus(FrameStatus status);
         void setDuration(unsigned duration) { m_duration = duration; }
         void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
         void setPremultiplyAlpha(bool premultiplyAlpha) { m_premultiplyAlpha = premultiplyAlpha; }
+        void setRequiredPreviousFrameIndex(size_t previousFrameIndex)
+        {
+            m_requiredPreviousFrameIndex = previousFrameIndex;
+#ifndef NDEBUG
+            m_requiredPreviousFrameIndexValid = true;
+#endif
+        }
 
         inline void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
         {
             setRGBA(getAddr(x, y), r, g, b, a);
         }
 
         inline PixelData* getAddr(int x, int y)
         {
             return m_bitmap->bitmap().getAddr32(x, y);
         }
@@ skipping 58 matching lines @@
         SkBitmap::Allocator* m_allocator;
         bool m_hasAlpha;
         IntRect m_originalFrameRect; // This will always just be the entire
                                      // buffer except for GIF frames whose
                                      // original rect was smaller than the
                                      // overall image size.
         FrameStatus m_status;
         unsigned m_duration;
         FrameDisposalMethod m_disposalMethod;
         bool m_premultiplyAlpha;
+
+        // The frame that must be decoded before this frame can be decoded.
+        // |notFound| if this frame doesn't require any previous frame.

[Peter Kasting, 2013/05/29 02:02:18]

Nit: Add this at end:

This is used by ImageDecoder::clearCacheExceptFrame(), and will never be read
for image formats that do not have multiple frames.

[Xianzhu, 2013/05/29 18:37:01]

Done.

+        size_t m_requiredPreviousFrameIndex;
+#ifndef NDEBUG
+        bool m_requiredPreviousFrameIndexValid;
+#endif
     };
 
     // ImageDecoder is a base for all format-specific decoders
     // (e.g. JPEGImageDecoder). This base manages the ImageFrame cache.
     class ImageDecoder {
         WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
     public:
         ImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
             : m_premultiplyAlpha(alphaOption == ImageSource::AlphaPremultiplied)
             , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == ImageSource::GammaAndColorProfileIgnored)
@@ skipping 138 matching lines @@
         // to enable easy tailcalling.  Subclasses may override this to also
         // clean up any local data.
         virtual bool setFailed()
         {
             m_failed = true;
             return false;
         }
 
         bool failed() const { return m_failed; }
 
-        // Clears decoded pixel data from before the provided frame unless that
+        // Clears decoded pixel data except the provided frame unless that
         // data may be needed to decode future frames (e.g. due to GIF frame
-        // compositing).
-        virtual void clearFrameBufferCache(size_t) { }
+        // compositing). Pass a value greater than the frame count to clear
+        // decoded pixel data of all frames.
+        // Returns number of bytes of the cleared frames.

[Peter Kasting, 2013/05/29 02:02:18]

Nit: How about this comment:

Clears decoded pixel data from all frames except the provided frame, unless that
frame has status FrameEmpty, in which case we instead preserve the most recent
frame whose data is required in order to decode this frame.  Callers may pass
WTF::notFound to clear all frames.

Returns the number of bytes of frame data actually cleared.

[Xianzhu, 2013/05/29 18:37:01]

Done.

+        size_t clearCacheExceptFrame(size_t);
 
         // If the image has a cursor hot-spot, stores it in the argument
         // and returns true. Otherwise returns false.
         virtual bool hotSpot(IntPoint&) const { return false; }
 
         virtual void reportMemoryUsage(MemoryObjectInfo*) const;
 
         virtual void setMemoryAllocator(SkBitmap::Allocator* allocator)
         {
             // FIXME: this doesn't work for images with multiple frames.
             if (m_frameBufferCache.isEmpty())
                 m_frameBufferCache.resize(1);
             m_frameBufferCache[0].setMemoryAllocator(allocator);
         }
 
     protected:
+        // Finds the previous required frame for decoding the given frame based
+        // on the parsed meta data. Returns notFound if this frame doesn't
+        // require any previous frame.
+        //
+        // Subclasses should call this function and cache the result by calling
+        // ImageFrame::setRequiredPreviousFrame() when a new frame is created,
+        // and must ensure all previous frame's required previous frame has been
+        // cached before calling this method.

[Peter Kasting, 2013/05/29 02:02:18]

Nit: How about this comment:

Calculates the most recent frame whose image data may be needed in order to
decode frame |frameIndex|, based on frame disposal methods.  If no previous
frame's data is required, returns WTF::notFound.

This function requires that the previous frame's |m_requiredPreviousFrameIndex|
member has been set correctly.  The easiest way to ensure this is for subclasses
to call this method and store the result on the frame via
setRequiredPreviousFrameIndex() as soon as the frame has been created and parsed
sufficiently to determine the disposal method; assuming this happens for all
frames in order, the required invariant will hold.

Image formats which do not use more than one frame do not need to worry about
this; see comments on ImageFrame::m_requiredPreviousFrameIndex.

[Xianzhu, 2013/05/29 18:37:01]

Done.

+        size_t findRequiredPreviousFrame(size_t frameIndex);
+
+        virtual void clearFrameBuffer(size_t frameIndex);
+
         RefPtr<SharedBuffer> m_data; // The encoded data.
         Vector<ImageFrame, 1> m_frameBufferCache;
         bool m_premultiplyAlpha;
         bool m_ignoreGammaAndColorProfile;
         ImageOrientation m_orientation;
 
     private:
         // Some code paths compute the size of the image as "width * height * 4"
         // and return it as a (signed) int.  Avoid overflow.
         static bool isOverSize(unsigned width, unsigned height)
         {
             unsigned long long total_size = static_cast<unsigned long long>(width)
                                           * static_cast<unsigned long long>(height);
             return total_size > ((1 << 29) - 1);
         }
 
         IntSize m_size;
         bool m_sizeAvailable;
         bool m_isAllDataReceived;
         bool m_failed;
     };
 
 } // namespace WebCore
 
 #endif