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 46 matching lines @@
         enum FrameDisposalMethod {
             // 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
         };
+        // Indicates how transparent pixels of the current frame rectangles are
+        // blended with those of the previous frame buffer.
+        enum FrameBlendingMethod {
+            BlendWithPrevious, // Compose the rectangle of current frame by blending it with corresponding pixels in the previous (disposed) framebuffer.
+            BlendOverwrite, // Compose the rectangle of current frame by over-writing the corresponding pixels in the previous (disposed) framebuffer.
+        };

[Peter Kasting, 2013/08/22 00:08:37]

I don't think I really understand what's going on with this enum.

Is this for cases where you only want to update a subframe of the image (and so
you want DisposeKeep for the previous frame, to preserve the space outside that
subframe), but within the subframe, you need to overwrite at least some of the
previous frame's pixels with new ones that have alpha != 255 (for which you'd
otherwise often have to use DisposeOverwriteBgcolor)?

If so, I suggest:
(1) Putting that motivation in a comment somewhere to give the reader context.
(2) Calling the two states "BlendAtopPreviousFrame" and "BlendAtopBgcolor"
(3) Possibly calling the enum AlphaBlendSourceForSubframe or some other name
that tries to be more descriptive about (a) this only happening for non-opaque
pixels and (b) this only happening within the current subframe (and being
unnecessary when the subframe is the full frame, since you'd just use an
appropriate disposal method in that case).

Otherwise, please tell me where I got things wrong.

[urvang (Google), 2013/08/22 01:49:36]

That's the idea, more of less.

To be more precise:  BlendOverwrite is useful for cases where one wants to
transform a few opaque pixels of previous frame into non-opaque pixels in the
current frame.
Done.
Done.
Done.
This isn't accurate actually.

Note that 'dispose method' specifies how a frame is treated after it is
displayed, while the 'blending method' specifies how the current frame is
blended with previous frame before display.

For example: consider a case where frame 2 is not a full frame, but frame 3 is.
Now, if frame 3 wanted to overwrite all pixels, none of the disposal method
would work (in the absence of BlendOverwrite).

[This is because frame disposal works on the frame rectangle of previous frame
only, and not the full previous frame].

See also:
https://gerrit.chromium.org/gerrit/#/c/65379/4/doc/webp-container-spec.txt

         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 30 matching lines @@
         // 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; }
         unsigned duration() const { return m_duration; }
         FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
+        FrameBlendingMethod blendingMethod() const { return m_blendingMethod; }
         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 setDuration(unsigned duration) { m_duration = duration; }
         void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
+        void setBlendingMethod(FrameBlendingMethod method) { m_blendingMethod = method; }
         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 48 matching lines @@
 
         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;
         unsigned m_duration;
         FrameDisposalMethod m_disposalMethod;
+        FrameBlendingMethod m_blendingMethod;
         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