Animated WebP: Optimize decoding in case of seeking

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 35 matching lines @@
 #include "wtf/RetainPtr.h"
 #endif
 #endif
 
 namespace WebCore {
 
     // ImageFrame represents the decoded image data.  This buffer is what all
     // decoders write a single frame into.
     class ImageFrame {
     public:
-        enum FrameStatus { FrameEmpty, FramePartial, FrameComplete };
-        enum FrameDisposalMethod {
+        enum Status { FrameEmpty, FramePartial, FrameComplete };
+        enum DisposalMethod {
             // If you change the numeric values of these, make sure you audit
             // all users, as some users may cast raw values to/from these
             // constants.
-            DisposeNotSpecified,      // Leave frame in framebuffer
-            DisposeKeep,              // Leave frame in framebuffer
-            DisposeOverwriteBgcolor,  // Clear frame to transparent
-            DisposeOverwritePrevious  // Clear frame to previous framebuffer
-                                      // contents
+            DisposeNotSpecified, // Leave frame in framebuffer
+            DisposeKeep, // Leave frame in framebuffer
+            DisposeOverwriteBgcolor, // Clear frame to fully transparent
+            DisposeOverwritePrevious // Clear frame to previous framebuffer contents
+        };
+        // Indicates how non-opaque pixels in the current frame rectangle
+        // are blended with those in the previous frame.
+        // Notes:
+        // * GIF always uses 'BlendAtopPreviousFrame'.
+        // * WebP also uses the 'BlendAtopBgcolor' option. This is useful for
+        //   cases where one wants to transform a few opaque pixels of the
+        //   previous frame into non-opaque pixels in the current frame.
+        enum AlphaBlendSource {
+            // Blend non-opaque pixels atop the corresponding pixels in the
+            // initial buffer state (i.e. any previous frame buffer after having
+            // been properly disposed).
+            BlendAtopPreviousFrame,
+
+            // Blend non-opaque pixels against fully transparent (i.e. simply
+            // overwrite the corresponding pixels).
+            BlendAtopBgcolor,
         };
         typedef uint32_t PixelData;
 
         ImageFrame();
 
         ImageFrame(const ImageFrame& other) { operator=(other); }
 
         // For backends which refcount their data, this operator doesn't need to
         // create a new copy of the image data, only increase the ref count.
         ImageFrame& operator=(const ImageFrame& other);
@@ skipping 28 matching lines @@
         // succeeded.
         bool setSize(int newWidth, int newHeight);
 
         // Returns a caller-owned pointer to the underlying native image data.
         // (Actual use: This pointer will be owned by BitmapImage and freed in
         // FrameData::clear()).
         PassRefPtr<NativeImageSkia> asNewNativeImage() const;
 
         bool hasAlpha() const;
         const IntRect& originalFrameRect() const { return m_originalFrameRect; }
-        FrameStatus status() const { return m_status; }
+        Status status() const { return m_status; }
         unsigned duration() const { return m_duration; }
-        FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
+        DisposalMethod disposalMethod() const { return m_disposalMethod; }
+        AlphaBlendSource alphaBlendSource() const { return m_alphaBlendSource; }
         bool premultiplyAlpha() const { return m_premultiplyAlpha; }
         SkBitmap::Allocator* allocator() const { return m_allocator; }
         const SkBitmap& getSkBitmap() const { return m_bitmap->bitmap(); }
 
         size_t requiredPreviousFrameIndex() const
         {
             ASSERT(m_requiredPreviousFrameIndexValid);
             return m_requiredPreviousFrameIndex;
         }
 #if !ASSERT_DISABLED
         bool requiredPreviousFrameIndexValid() const { return m_requiredPreviousFrameIndexValid; }
 #endif
         void setHasAlpha(bool alpha);
         void setOriginalFrameRect(const IntRect& r) { m_originalFrameRect = r; }
-        void setStatus(FrameStatus status);
+        void setStatus(Status);
         void setDuration(unsigned duration) { m_duration = duration; }
-        void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
+        void setDisposalMethod(DisposalMethod disposalMethod) { m_disposalMethod = disposalMethod; }
+        void setAlphaBlendSource(AlphaBlendSource alphaBlendSource) { m_alphaBlendSource = alphaBlendSource; }
         void setPremultiplyAlpha(bool premultiplyAlpha) { m_premultiplyAlpha = premultiplyAlpha; }
         void setMemoryAllocator(SkBitmap::Allocator* allocator) { m_allocator = allocator; }
         void setSkBitmap(const SkBitmap& bitmap) { m_bitmap = NativeImageSkia::create(bitmap); }
 
         void setRequiredPreviousFrameIndex(size_t previousFrameIndex)
         {
             m_requiredPreviousFrameIndex = previousFrameIndex;
 #if !ASSERT_DISABLED
             m_requiredPreviousFrameIndexValid = true;
 #endif
@@ skipping 45 matching lines @@
         {
             return m_bitmap->bitmap().height();
         }
 
         RefPtr<NativeImageSkia> m_bitmap;
         SkBitmap::Allocator* m_allocator;
         bool m_hasAlpha;
         // This will always just be the entire buffer except for GIF or WebP
         // frames whose original rect was smaller than the overall image size.
         IntRect m_originalFrameRect;
-        FrameStatus m_status;
+        Status m_status;
         unsigned m_duration;
-        FrameDisposalMethod m_disposalMethod;
+        DisposalMethod m_disposalMethod;
+        AlphaBlendSource m_alphaBlendSource;
         bool m_premultiplyAlpha;
 
         // The frame that must be decoded before this frame can be decoded.
         // WTF::notFound if this frame doesn't require any previous frame.
         // This is used by ImageDecoder::clearCacheExceptFrame(), and will never
         // be read for image formats that do not have multiple frames.
         size_t m_requiredPreviousFrameIndex;
 #if !ASSERT_DISABLED
         bool m_requiredPreviousFrameIndexValid;
 #endif
@@ skipping 164 matching lines @@
         // 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 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].setRequiredPreviousFrameIndex(
-                    findRequiredPreviousFrame(0));
+                    findRequiredPreviousFrame(0, false));
             }
             m_frameBufferCache[0].setMemoryAllocator(allocator);
         }
 
     protected:
         // Calculates the most recent frame whose image data may be needed in
-        // order to decode frame |frameIndex|, based on frame disposal methods.
+        // order to decode frame |frameIndex|, based on frame disposal methods
+        // and |frameRectIsOpaque|, where |frameRectIsOpaque| signifies whether
+        // the rectangle of frame at |frameIndex| is known to be opaque.
         // 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.
-        size_t findRequiredPreviousFrame(size_t frameIndex);
+        size_t findRequiredPreviousFrame(size_t frameIndex, bool frameRectIsOpaque);
 
         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