Move gif image decoder to SkCodec

third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp

Index: third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp
diff --git a/third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp b/third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp
index 357917f67d3cff36f6b0a9e23a76c2d9e9ad86c2..307c604ab99c5125af19d115bf391be7a69a4510 100644
--- a/third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp
+++ b/third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp
@@ -25,7 +25,7 @@
 
 #include "platform/image-decoders/gif/GIFImageDecoder.h"
 
-#include "platform/image-decoders/gif/GIFImageReader.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
 #include "wtf/NotFound.h"
 #include "wtf/PtrUtil.h"
 #include <limits>
@@ -36,246 +36,316 @@ GIFImageDecoder::GIFImageDecoder(AlphaOption alphaOption,
                                  const ColorBehavior& colorBehavior,
                                  size_t maxDecodedBytes)
     : ImageDecoder(alphaOption, colorBehavior, maxDecodedBytes),
-      m_repetitionCount(cAnimationLoopOnce) {}
-
-GIFImageDecoder::~GIFImageDecoder() {}
+      m_codec(),
+      m_segmentStream(nullptr) {}
+
+GIFImageDecoder::~GIFImageDecoder() {
+  if (!m_codec) {
+    // if we did not create m_codec and thus did not pass ownership to it
+    if (m_segmentStream) {
+      delete m_segmentStream;
+    }
+  }
+}
 
 void GIFImageDecoder::onSetData(SegmentReader* data) {
-  if (m_reader)
-    m_reader->setData(data);
+  if (!data) {
+    return;
+  }
+
+  if (!m_segmentStream) {
+    m_segmentStream = new SegmentStream();
+  }
+
+  if (!m_segmentStream) {
+    return;
+  }
+
+  m_segmentStream->setReader(data, isAllDataReceived());
+
+  // If we don't have a SkCodec yet, create one from the stream
+  if (!m_codec) {
+    SkCodec* codec = SkCodec::NewFromStream(m_segmentStream);
+    if (codec) {
+      m_codec.reset(codec);
+    } else {
+      // m_segmentStream's ownership is passed. It is deleted if SkCodec
+      // creation fails. In this case, release our reference so we can create a
+      // new SegmentStream later.
+      m_segmentStream = nullptr;
+      return;
+    }
+
+    // SkCodec::NewFromStream will read enough of the image to get the image
+    // size.
+    SkImageInfo imageInfo = m_codec->getInfo();
+    setSize(imageInfo.width(), imageInfo.height());
+  }
 }
 
 int GIFImageDecoder::repetitionCount() const {
+  if (!m_codec) {
+    return 0;
+  }
+
   // This value can arrive at any point in the image data stream.  Most GIFs
   // in the wild declare it near the beginning of the file, so it usually is
   // set by the time we've decoded the size, but (depending on the GIF and the
-  // packets sent back by the webserver) not always.  If the reader hasn't
-  // seen a loop count yet, it will return cLoopCountNotSeen, in which case we
-  // should default to looping once (the initial value for
-  // |m_repetitionCount|).
-  //
-  // There are some additional wrinkles here. First, ImageSource::clear()
-  // may destroy the reader, making the result from the reader _less_
-  // authoritative on future calls if the recreated reader hasn't seen the
-  // loop count.  We don't need to special-case this because in this case the
-  // new reader will once again return cLoopCountNotSeen, and we won't
-  // overwrite the cached correct value.
-  //
-  // Second, a GIF might never set a loop count at all, in which case we
-  // should continue to treat it as a "loop once" animation.  We don't need
-  // special code here either, because in this case we'll never change
-  // |m_repetitionCount| from its default value.
+  // packets sent back by the webserver) not always.
   //
-  // Third, we use the same GIFImageReader for counting frames and we might
-  // see the loop count and then encounter a decoding error which happens
-  // later in the stream. It is also possible that no frames are in the
-  // stream. In these cases we should just loop once.
-  if (isAllDataReceived() && parseCompleted() && m_reader->imagesCount() == 1)
-    m_repetitionCount = cAnimationNone;
-  else if (failed() || (m_reader && (!m_reader->imagesCount())))
-    m_repetitionCount = cAnimationLoopOnce;
-  else if (m_reader && m_reader->loopCount() != cLoopCountNotSeen)
-    m_repetitionCount = m_reader->loopCount();
-  return m_repetitionCount;
+  // SkCodec will parse forward in the file if the repetition count has not been
+  // seen yet.
+
+  int repetitionCount = m_codec->getRepetitionCount();
+  switch (repetitionCount) {
+    case 0:
+      return cAnimationNone;
+    case SkCodec::kRepetitionCountInfinite:
+      return cAnimationLoopInfinite;
+    default:
+      return repetitionCount;
+  }
 }
 
 bool GIFImageDecoder::frameIsCompleteAtIndex(size_t index) const {
-  return m_reader && (index < m_reader->imagesCount()) &&
-         m_reader->frameContext(index)->isComplete();
-}
-
-float GIFImageDecoder::frameDurationAtIndex(size_t index) const {
-  return (m_reader && (index < m_reader->imagesCount()) &&
-          m_reader->frameContext(index)->isHeaderDefined())
-             ? m_reader->frameContext(index)->delayTime()
-             : 0;
-}
-
-bool GIFImageDecoder::setFailed() {
-  m_reader.reset();
-  return ImageDecoder::setFailed();
-}
-
-bool GIFImageDecoder::haveDecodedRow(size_t frameIndex,
-                                     GIFRow::const_iterator rowBegin,
-                                     size_t width,
-                                     size_t rowNumber,
-                                     unsigned repeatCount,
-                                     bool writeTransparentPixels) {
-  const GIFFrameContext* frameContext = m_reader->frameContext(frameIndex);
-  // The pixel data and coordinates supplied to us are relative to the frame's
-  // origin within the entire image size, i.e.
-  // (frameContext->xOffset, frameContext->yOffset). There is no guarantee
-  // that width == (size().width() - frameContext->xOffset), so
-  // we must ensure we don't run off the end of either the source data or the
-  // row's X-coordinates.
-  const int xBegin = frameContext->xOffset();
-  const int yBegin = frameContext->yOffset() + rowNumber;
-  const int xEnd = std::min(static_cast<int>(frameContext->xOffset() + width),
-                            size().width());
-  const int yEnd = std::min(
-      static_cast<int>(frameContext->yOffset() + rowNumber + repeatCount),
-      size().height());
-  if (!width || (xBegin < 0) || (yBegin < 0) || (xEnd <= xBegin) ||
-      (yEnd <= yBegin))
-    return true;
-
-  const GIFColorMap::Table& colorTable =
-      frameContext->localColorMap().isDefined()
-          ? frameContext->localColorMap().getTable()
-          : m_reader->globalColorMap().getTable();
-
-  if (colorTable.isEmpty())
-    return true;
-
-  GIFColorMap::Table::const_iterator colorTableIter = colorTable.begin();
-
-  // Initialize the frame if necessary.
-  ImageFrame& buffer = m_frameBufferCache[frameIndex];
-  if (!initFrameBuffer(frameIndex))
+  if (!m_codec) {
     return false;
-
-  const size_t transparentPixel = frameContext->transparentPixel();
-  GIFRow::const_iterator rowEnd = rowBegin + (xEnd - xBegin);
-  ImageFrame::PixelData* currentAddress = buffer.getAddr(xBegin, yBegin);
-
-  // We may or may not need to write transparent pixels to the buffer.
-  // If we're compositing against a previous image, it's wrong, and if
-  // we're writing atop a cleared, fully transparent buffer, it's
-  // unnecessary; but if we're decoding an interlaced gif and
-  // displaying it "Haeberli"-style, we must write these for passes
-  // beyond the first, or the initial passes will "show through" the
-  // later ones.
-  //
-  // The loops below are almost identical. One writes a transparent pixel
-  // and one doesn't based on the value of |writeTransparentPixels|.
-  // The condition check is taken out of the loop to enhance performance.
-  // This optimization reduces decoding time by about 15% for a 3MB image.
-  if (writeTransparentPixels) {
-    for (; rowBegin != rowEnd; ++rowBegin, ++currentAddress) {
-      const size_t sourceValue = *rowBegin;
-      if ((sourceValue != transparentPixel) &&
-          (sourceValue < colorTable.size())) {
-        *currentAddress = colorTableIter[sourceValue];
-      } else {
-        *currentAddress = 0;
-        m_currentBufferSawAlpha = true;
-      }
-    }
-  } else {
-    for (; rowBegin != rowEnd; ++rowBegin, ++currentAddress) {
-      const size_t sourceValue = *rowBegin;
-      if ((sourceValue != transparentPixel) &&
-          (sourceValue < colorTable.size()))
-        *currentAddress = colorTableIter[sourceValue];
-      else
-        m_currentBufferSawAlpha = true;
-    }
   }
 
-  // Tell the frame to copy the row data if need be.
-  if (repeatCount > 1)
-    buffer.copyRowNTimes(xBegin, xEnd, yBegin, yEnd);
-
-  buffer.setPixelsChanged(true);
-  return true;
-}
+  std::vector<SkCodec::FrameInfo> frameInfos = m_codec->getFrameInfo();
+  if (frameInfos.size() <= index) {
+    return false;
+  }
 
-bool GIFImageDecoder::parseCompleted() const {
-  return m_reader && m_reader->parseCompleted();
+  return frameInfos[index].fFullyReceived;
 }
 
-bool GIFImageDecoder::frameComplete(size_t frameIndex) {
-  // Initialize the frame if necessary.  Some GIFs insert do-nothing frames,
-  // in which case we never reach haveDecodedRow() before getting here.
-  if (!initFrameBuffer(frameIndex))
-    return false;  // initFrameBuffer() has already called setFailed().
+float GIFImageDecoder::frameDurationAtIndex(size_t index) const {
+  if (!m_codec) {
+    return 0;
+  }
 
-  m_frameBufferCache[frameIndex].setStatus(ImageFrame::FrameComplete);
-  if (!m_currentBufferSawAlpha)
-    correctAlphaWhenFrameBufferSawNoAlpha(frameIndex);
+  std::vector<SkCodec::FrameInfo> frameInfos = m_codec->getFrameInfo();
+  if (frameInfos.size() <= index) {
+    return 0;
+  }
 
-  return true;
+  return frameInfos[index].fDuration;
 }
 
-void GIFImageDecoder::clearFrameBuffer(size_t frameIndex) {
-  if (m_reader &&
-      m_frameBufferCache[frameIndex].getStatus() == ImageFrame::FramePartial) {
-    // Reset the state of the partial frame in the reader so that the frame
-    // can be decoded again when requested.
-    m_reader->clearDecodeState(frameIndex);
+size_t GIFImageDecoder::decodeFrameCount() {
+  if (!m_codec) {
+    return 0;
   }
-  ImageDecoder::clearFrameBuffer(frameIndex);
-}
 
-size_t GIFImageDecoder::decodeFrameCount() {
-  parse(GIFFrameCountQuery);
-  // If decoding fails, |m_reader| will have been destroyed.  Instead of
-  // returning 0 in this case, return the existing number of frames.  This way
-  // if we get halfway through the image before decoding fails, we won't
-  // suddenly start reporting that the image has zero frames.
-  return failed() ? m_frameBufferCache.size() : m_reader->imagesCount();
+  std::vector<SkCodec::FrameInfo> frameInfos = m_codec->getFrameInfo();
+  return frameInfos.size();
 }
 
 void GIFImageDecoder::initializeNewFrame(size_t index) {
-  ImageFrame* buffer = &m_frameBufferCache[index];
-  const GIFFrameContext* frameContext = m_reader->frameContext(index);
-  buffer->setOriginalFrameRect(
-      intersection(frameContext->frameRect(), IntRect(IntPoint(), size())));
-  buffer->setDuration(frameContext->delayTime());
-  buffer->setDisposalMethod(frameContext->getDisposalMethod());
-  buffer->setRequiredPreviousFrameIndex(
-      findRequiredPreviousFrame(index, false));
+  if (!m_codec) {
+    return;
+  }
+
+  ImageFrame& frame = m_frameBufferCache[index];
+  std::vector<SkCodec::FrameInfo> frameInfos = m_codec->getFrameInfo();
+
+  // FIXME We may not need to fill in all this frame information.
+  // SkCodec doesn't need it. Check if Blink uses it at all.
+  // If Blink does use it, maybe SkCodec can provide it to us.
+  IntSize frameSize = size();
+  frame.setOriginalFrameRect(IntRect(IntPoint(), frameSize));
+  frame.setDuration(frameInfos[index].fDuration);
+  // The disposal method is not required any more, but is left in place
+  // for the other image decoders that do not yet rely on SkCodec.
+  // For now, fill it with DisposeKeep.
+  frame.setDisposalMethod(ImageFrame::DisposeKeep);
+  size_t requiredPreviousFrame = frameInfos[index].fRequiredFrame;
+  if (requiredPreviousFrame == SkCodec::kNone) {
+    requiredPreviousFrame = WTF::kNotFound;
+    // TODO: When Blink sees an image it creates a decoder just to get the width
+    // and height of the image. During this time, we are now allocating the
+    // first frame. We might allocate extras if they are not dependent frames.
+    // That image decoder is then destroyed and the frame allocations are wasted
+    // (causing a useless memory spike). We should move the frame allocation
+    // elsewhere.

[cblume, 2017/01/30 07:35:48]

I'm going to want to address this before we finish this patch.

+    frame.setSizeAndColorSpace(frameSize.width(), frameSize.height(),
+                               colorSpaceForSkImages());
+  }
+  frame.setRequiredPreviousFrameIndex(requiredPreviousFrame);
 }
 
 void GIFImageDecoder::decode(size_t index) {
-  parse(GIFFrameCountQuery);
+  if (failed()) {
+    return;
+  }
+
+  if (!m_codec) {
+    return;
+  }
+
+  if (m_frameBufferCache.size() <= index) {
+    // It is a fatal error if all data is received and we have decoded all
+    // frames available but the file is truncated.
+    if (isAllDataReceived()) {
+      setFailed();
+    }
 
-  if (failed())
     return;
+  }
 
   updateAggressivePurging(index);
 
-  Vector<size_t> framesToDecode = findFramesToDecode(index);
-  for (auto i = framesToDecode.rbegin(); i != framesToDecode.rend(); ++i) {
-    if (!m_reader->decode(*i)) {
-      setFailed();
-      return;
+  SkImageInfo imageInfo = m_codec->getInfo().makeColorType(kN32_SkColorType);
+
+  ImageFrame& frame = m_frameBufferCache[index];
+
+  std::vector<SkCodec::FrameInfo> frameInfos = m_codec->getFrameInfo();
+  IntSize frameSize = size();
+  frame.setOriginalFrameRect(IntRect(IntPoint(), frameSize));
+  frame.setDuration(frameInfos[index].fDuration);
+  // The disposal method is not required any more, but is left in place
+  // for the other image decoders that do not yet rely on SkCodec.
+  // For now, fill it with DisposeKeep.
+  frame.setDisposalMethod(ImageFrame::DisposeKeep);
+  size_t requiredPreviousFrame = frameInfos[index].fRequiredFrame;
+  if (requiredPreviousFrame == SkCodec::kNone) {
+    requiredPreviousFrame = WTF::kNotFound;
+    // TODO: When Blink sees an image it creates a decoder just to get the width
+    // and height of the image. During this time, we are now allocating the
+    // first frame. We might allocate extras if they are not dependent frames.
+    // That image decoder is then destroyed and the frame allocations are wasted
+    // (causing a useless memory spike). We should move the frame allocation
+    // elsewhere.
+    /*
+    frame.setSizeAndColorSpace(frameSize.width(), frameSize.height(),
+                               colorSpaceForSkImages());
+    */
+  }
+  frame.setRequiredPreviousFrameIndex(requiredPreviousFrame);
+
+  if (frame.requiredPreviousFrameIndex() != requiredPreviousFrame) {
+    std::cout << "!!!!!!!! bad previous frame" << std::endl;
+  }

[cblume, 2017/01/30 07:35:48]

This whole chunk is basically copied and pasted from initializeNewFrame. It
appeared like at this point the frame did not know it required a previous frame
when data streamed in 1 byte at a time. With full data, the previous frame was
known. I put this here temporarily to enforce that the required previous frame
(and any other frame init) was done.

+
+  size_t requiredPreviousFrameIndex = frame.requiredPreviousFrameIndex();
+
+  SkCodec::Options options;
+  options.fFrameIndex = index;
+  options.fHasPriorFrame = false;
+  if (requiredPreviousFrameIndex != WTF::kNotFound) {
+    options.fHasPriorFrame = true;
+  }
+
+  if (frame.getStatus() == ImageFrame::FrameEmpty) {
+    if (requiredPreviousFrameIndex != WTF::kNotFound) {
+      ImageFrame& requiredPreviousFrame =
+          m_frameBufferCache[requiredPreviousFrameIndex];
+
+      // We try to reuse |requiredPreviousFrame| as starting state to avoid
+      // copying. If canReusePreviousFrameBuffer returns false, we must copy
+      // the data since |requiredPreviousFrame| is necessary to decode this
+      // or later frames. In that case copy the data instead.
+      /*
+      if ((!canReusePreviousFrameBuffer(index) ||
+           !frame.takeBitmapDataIfWritable(&requiredPreviousFrame)) &&
+          !frame.copyBitmapData(requiredPreviousFrame)) {
+          */
+      /*
+      frame.setSizeAndColorSpace(frameSize.width(), frameSize.height(),
+                             colorSpaceForSkImages());*/
+
+      if (!frame.copyBitmapData(requiredPreviousFrame)) {

[cblume, 2017/01/30 07:35:48]

I wanted to only copy, not take -- again, temporary to reduce the bug path.

+        setFailed();
+        return;
+      }
+      // frame.setPixelsChanged(true);
+      // frame.setStatus(ImageFrame::FramePartial);
+      // frame.setStatus(ImageFrame::FrameComplete);
+      // return;
     }
 
-    // If this returns false, we need more data to continue decoding.
-    if (!postDecodeProcessing(*i))
-      break;
+    SkCodec::Result startIncrementalDecodeResult =
+        m_codec->startIncrementalDecode(imageInfo, frame.bitmap().getPixels(),
+                                        frame.bitmap().rowBytes(), &options,
+                                        nullptr, nullptr);
+    switch (startIncrementalDecodeResult) {
+      case SkCodec::kSuccess:
+        break;
+      case SkCodec::kIncompleteInput:
+        return;
+      default:
+        setFailed();
+        return;
+    }
   }
 
-  // It is also a fatal error if all data is received and we have decoded all
-  // frames available but the file is truncated.
-  if (index >= m_frameBufferCache.size() - 1 && isAllDataReceived() &&
-      m_reader && !m_reader->parseCompleted())
-    setFailed();
+  int rowsDecoded = 0;
+  SkCodec::Result incrementalDecodeResult =
+      m_codec->incrementalDecode(&rowsDecoded);
+  switch (incrementalDecodeResult) {
+    case SkCodec::kSuccess:
+      correctAlphaWhenFrameBufferSawNoAlpha(index);
+      frame.setPixelsChanged(true);
+      frame.setStatus(ImageFrame::FrameComplete);
+      break;
+    case SkCodec::kIncompleteInput:
+      if (isAllDataReceived()) {
+        setFailed();
+        return;
+      }
+
+      if (frame.getStatus() == ImageFrame::FrameEmpty && index == 0) {
+        // We want to display the bit of the frame we have decoded only if it is
+        // the first frame of an animation. That means we need to fill the rest
+        // of the image with transparent.
+        IntRect remainingRect = frame.originalFrameRect();
+        remainingRect.setY(rowsDecoded);
+        remainingRect.setHeight(remainingRect.height() - rowsDecoded);
+        // frame.zeroFillFrameRect(remainingRect);
+
+        frame.setPixelsChanged(true);
+        frame.setStatus(ImageFrame::FramePartial);
+      }
+
+      // frame.setPixelsChanged(true);
+      // frame.setStatus(ImageFrame::FramePartial);
+      break;
+    default:
+      setFailed();
+      return;
+  }
+  if (frame.getStatus() == ImageFrame::FrameComplete) {
+    if (!postDecodeProcessing(index)) {
+      return;
+    }
+  }
 }
 
-void GIFImageDecoder::parse(GIFParseQuery query) {
-  if (failed())
-    return;
+bool GIFImageDecoder::canReusePreviousFrameBuffer(size_t index) const {
+  DCHECK(index < m_frameBufferCache.size());
+
+  // If the current frame and the next frame depend on the same frame, we cannot
+  // reuse the old frame. We must preserve it for the next frame.
+  //
+  // However, if the current and next frame depend on different frames then we
+  // know the current frame is the last one to use the frame it depends on. That
+  // means the current frame can reuse the previous frame buffer.
+  //
+  // If we do not have information about the next frame yet, we cannot assume it
+  // is safe to reuse the previous frame buffer.
 
-  if (!m_reader) {
-    m_reader = WTF::makeUnique<GIFImageReader>(this);
-    m_reader->setData(m_data);
+  if (index + 1 >= m_frameBufferCache.size()) {
+    return false;
   }
 
-  if (!m_reader->parse(query))
-    setFailed();
-}
+  const ImageFrame& frame = m_frameBufferCache[index];
+  size_t requiredFrameIndex = frame.requiredPreviousFrameIndex();
 
-void GIFImageDecoder::onInitFrameBuffer(size_t frameIndex) {
-  m_currentBufferSawAlpha = false;
-}
+  const ImageFrame& nextFrame = m_frameBufferCache[index + 1];
+  size_t nextRequiredFrameIndex = nextFrame.requiredPreviousFrameIndex();
 
-bool GIFImageDecoder::canReusePreviousFrameBuffer(size_t frameIndex) const {
-  DCHECK(frameIndex < m_frameBufferCache.size());
-  return m_frameBufferCache[frameIndex].getDisposalMethod() !=
-         ImageFrame::DisposeOverwritePrevious;
+  return requiredFrameIndex != nextRequiredFrameIndex;
 }
 
 }  // namespace blink