Decode GIF image frames on demand.

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

 /*
  * Copyright (C) 2008-2009 Torch Mobile, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
@@ skipping 209 matching lines @@
 int ImageDecoder::lowerBoundScaledY(int origY, int searchStart)
 {
     return getScaledValue<LowerBound>(m_scaledRows, origY, searchStart);
 }
 
 int ImageDecoder::scaledY(int origY, int searchStart)
 {
     return getScaledValue<Exact>(m_scaledRows, origY, searchStart);
 }
 
+void ImageDecoder::clearFrameBufferCache(size_t clearExceptFrame)

[Alpha Left Google, 2013/05/22 20:18:09]

I'm not sure you should move this to the base class given that this is relavent
to only animated GIFs. Animated WebP has their internal methods for clearing.

[Xianzhu, 2013/05/22 23:43:29]

I thought as the disposal methods are defined in common ImageDecoder.h and the
rules seems common so I moved it here and expected that WebP could reuse it.
WebP has less disposal methods but they should be covered. Can it reuse?

+{
+    // Don't clear if there is no or only one frame.
+    if (m_frameBufferCache.size() <= 1)
+        return;
+
+    // We need to preserve frames such that:
+    //  1. We don't clear |clearExceptFrame|;
+    //  2. We don't clear any frame from which a future initFrameBuffer() call
+    //     will copy bitmap data.
+    //  3. We don't clear empty frames or the frame we're currently decoding;
+    // All other frames can be cleared.
+    size_t frameToBeRequired;
+    if (clearExceptFrame < m_frameBufferCache.size() && m_frameBufferCache[clearExceptFrame].status() == ImageFrame::FrameEmpty) {
+        frameToBeRequired = clearExceptFrame;
+        do {
+            frameToBeRequired = m_frameBufferCache[frameToBeRequired].requiredPreviousFrameIndex();
+        } while (frameToBeRequired != notFound && m_frameBufferCache[frameToBeRequired].status() != ImageFrame::FrameComplete);

[Xianzhu, 2013/05/22 23:43:29]

Changed the above condition to ...== ImageFrame::FrameEmpty because a partial
frame can also be the frame to be required.

Also changed GIFImageDecoder::decode() so that we don't go back beyond a partial
frame whose initFrameBuffer() has already been called so doesn't require another
previous frame.

+    } else {
+        // initFrameBuffer() has already been called for this frame.
+        frameToBeRequired = notFound;
+    }
+
+    for (size_t i = 0; i < m_frameBufferCache.size(); ++i) {
+        if (i == clearExceptFrame || i == frameToBeRequired) // 1 and 2.
+            continue;
+
+        ImageFrame& frame = m_frameBufferCache[i];
+        if (frame.status() == ImageFrame::FrameComplete) // 3.

[Alpha Left Google, 2013/05/22 20:18:09]

Using this condition you'll hit a corner case where a couple of frames are
partially decoded. This will leave multiple frames we don't need and also not
cleared. Clearing these frames will be more involved because you need to clear
the states for individual frames in the reader as well.

[Xianzhu, 2013/05/22 23:43:29]

Changed to clear partial frames. However, I'm not sure what states to clear in
the reader. Can the states be used the next time when the frame is decoded
again?

[Xianzhu, 2013/05/23 00:33:49]

Never mind this question. I know the answer now :) We need to clear the reader
status to reflect the cleared frame data

+            frame.clearPixelData();
+    }
+}
+
+size_t ImageDecoder::findRequiredPreviousFrame(size_t frameIndex)
+{
+    if (!frameIndex) {
+        // The first frame doesn't rely on any previous data.
+        return notFound;
+    }
+
+    // The starting state for this frame depends on the previous frame's
+    // disposal method.
+    //
+    // Frames that use the DisposeOverwritePrevious method are effectively
+    // no-ops in terms of changing the starting state of a frame compared to
+    // the starting state of the previous frame, so skip over them.  (If the
+    // first frame specifies this method, it will get treated like
+    // DisposeOverwriteBgcolor below and reset to a completely empty image.)
+    size_t prevFrame = frameIndex - 1;
+    const ImageFrame* prevBuffer = &m_frameBufferCache[prevFrame];
+    ImageFrame::FrameDisposalMethod prevMethod = prevBuffer->disposalMethod();
+    while (prevFrame && (prevMethod == ImageFrame::DisposeOverwritePrevious)) {
+        prevBuffer = &m_frameBufferCache[--prevFrame];
+        prevMethod = prevBuffer->disposalMethod();
+    }
+
+    if (prevMethod == ImageFrame::DisposeNotSpecified || prevMethod == ImageFrame::DisposeKeep) {
+        // prevFrame will be used as the starting state for this frame.
+        return prevFrame;
+    }
+
+    if (!prevFrame) {
+        // The first frame whose disposal method is DisposeOverwriteBgColor or
+        // DisposeOverritePrevious will be reset to background despite its size.
+        return notFound;
+    }
+
+    ASSERT(prevMethod == ImageFrame::DisposeOverwriteBgcolor);
+    const IntRect& prevRect = prevBuffer->originalFrameRect();
+    const IntSize& bufferSize = scaledSize();
+    if (prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
+        // prevFrame covering the whole image will be reset to background,
+        return notFound;
+    }
+
+    // prevFrame only clears part of the image to background, so it contributes
+    // to the starting state of this frame.
+    return prevFrame;
+}
+
 } // namespace WebCore