Add support for Animated PNG

third_party/WebKit/Source/platform/image-decoders/png/PNGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Portions are Copyright (C) 2001 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 20 matching lines @@
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
  * deletingthe provisions above and replace them with the notice and
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "platform/image-decoders/png/PNGImageDecoder.h"
 
-#include "platform/image-decoders/png/PNGImageReader.h"
-#include "png.h"
-#include "wtf/PtrUtil.h"
-#include <memory>
-
 namespace blink {
 
 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption,
                                  const ColorBehavior& colorBehavior,
                                  size_t maxDecodedBytes,
                                  size_t offset)
     : ImageDecoder(alphaOption, colorBehavior, maxDecodedBytes),
-      m_offset(offset) {}
+      m_offset(offset),
+      m_currentFrame(0),
+      // It would be logical to default to cAnimationNone, but BitmapImage uses
+      // that as a signal to never check again, meaning the actual count will
+      // never be respected.
+      m_repetitionCount(cAnimationLoopOnce),
+      m_hasAlphaChannel(false),
+      m_currentBufferSawAlpha(false) {}
 
 PNGImageDecoder::~PNGImageDecoder() {}
 
+bool PNGImageDecoder::setFailed() {
+  m_reader.reset();
+  return ImageDecoder::setFailed();
+}
+
+size_t PNGImageDecoder::decodeFrameCount() {
+  parse(ParseQuery::MetaData);
+  return failed() ? m_frameBufferCache.size() : m_reader->frameCount();
+}
+
+void PNGImageDecoder::decode(size_t index) {
+  parse(ParseQuery::MetaData);
+
+  if (failed())
+    return;
+
+  updateAggressivePurging(index);
+
+  Vector<size_t> framesToDecode = findFramesToDecode(index);
+  for (auto i = framesToDecode.rbegin(); i != framesToDecode.rend(); i++) {
+    m_currentFrame = *i;
+    if (!m_reader->decode(*m_data, *i)) {
+      setFailed();
+      return;
+    }
+
+    // If this returns false, we need more data to continue decoding.
+    if (!postDecodeProcessing(*i))
+      break;
+  }
+
+  // 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();
+}
+
+void PNGImageDecoder::parse(ParseQuery query) {
+  if (failed() || (m_reader && m_reader->parseCompleted()))
+    return;
+
+  if (!m_reader)
+    m_reader = WTF::makeUnique<PNGImageReader>(this, m_offset);
+
+  if (!m_reader->parse(*m_data, query))
+    setFailed();
+}
+
+void PNGImageDecoder::clearFrameBuffer(size_t index) {
+  if (m_reader)
+    m_reader->clearDecodeState(index);
+  ImageDecoder::clearFrameBuffer(index);
+}
+
+bool PNGImageDecoder::canReusePreviousFrameBuffer(size_t index) const {
+  DCHECK(index < m_frameBufferCache.size());
+  return m_frameBufferCache[index].getDisposalMethod() !=
+         ImageFrame::DisposeOverwritePrevious;
+}
+
+void PNGImageDecoder::setRepetitionCount(int repetitionCount) {
+  m_repetitionCount = repetitionCount;
+}
+
+int PNGImageDecoder::repetitionCount() const {
+  return failed() ? cAnimationLoopOnce : m_repetitionCount;
+}
+
+void PNGImageDecoder::initializeNewFrame(size_t index) {
+  const PNGImageReader::FrameInfo& frameInfo = m_reader->frameInfo(index);
+  ImageFrame& buffer = m_frameBufferCache[index];
+
+  DCHECK(IntRect(IntPoint(), size()).contains(frameInfo.frameRect));
+  buffer.setOriginalFrameRect(frameInfo.frameRect);
+
+  buffer.setDuration(frameInfo.duration);
+  buffer.setDisposalMethod(frameInfo.disposalMethod);
+  buffer.setAlphaBlendSource(frameInfo.alphaBlend);
+
+  size_t previousFrameIndex = findRequiredPreviousFrame(index, false);
+  buffer.setRequiredPreviousFrameIndex(previousFrameIndex);
+}
+
 inline sk_sp<SkColorSpace> readColorSpace(png_structp png, png_infop info) {
   if (png_get_valid(png, info, PNG_INFO_sRGB))
     return SkColorSpace::MakeSRGB();
 
   png_charp name;
   int compression;
   png_bytep profile;
   png_uint_32 length;
   if (png_get_iCCP(png, info, &name, &compression, &profile, &length))
     return SkColorSpace::MakeICC(profile, length);
@@ skipping 37 matching lines @@
   fn.fG = 1.0f / pngFixedToFloat(inverseGamma);
   fn.fA = 1.0f;
   fn.fB = fn.fC = fn.fD = fn.fE = fn.fF = 0.0f;
 
   return SkColorSpace::MakeRGB(fn, toXYZD50);
 }
 
 void PNGImageDecoder::headerAvailable() {
   png_structp png = m_reader->pngPtr();
   png_infop info = m_reader->infoPtr();
-  png_uint_32 width = png_get_image_width(png, info);
-  png_uint_32 height = png_get_image_height(png, info);
 
-  // Protect against large PNGs. See http://bugzil.la/251381 for more details.
-  const unsigned long maxPNGSize = 1000000UL;
-  if (width > maxPNGSize || height > maxPNGSize) {
-    longjmp(JMPBUF(png), 1);
-    return;
-  }
-
-  // Set the image size now that the image header is available.
-  if (!setSize(width, height)) {
-    longjmp(JMPBUF(png), 1);
-    return;
-  }
-
+  png_uint_32 width, height;
   int bitDepth, colorType, interlaceType, compressionType;
   png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType,
                &interlaceType, &compressionType, nullptr);
 
   // The options we set here match what Mozilla does.
 
   // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
   if (colorType == PNG_COLOR_TYPE_PALETTE ||
       (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
     png_set_expand(png);
 
   if (png_get_valid(png, info, PNG_INFO_tRNS))
     png_set_expand(png);
 
   if (bitDepth == 16)
     png_set_strip_16(png);
 
   if (colorType == PNG_COLOR_TYPE_GRAY ||
       colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
     png_set_gray_to_rgb(png);
 
-  if ((colorType & PNG_COLOR_MASK_COLOR) && !ignoresColorSpace()) {
-    // We only support color profiles for color PALETTE and RGB[A] PNG.
-    // TODO(msarret): Add GRAY profile support, block CYMK?
-    if (sk_sp<SkColorSpace> colorSpace = readColorSpace(png, info))
-      setEmbeddedColorSpace(std::move(colorSpace));
+  // Only set the size and the color space of the image once since non-first
+  // frames also use this method: there is no per-frame color space, and the
+  // image size is determined from the header width and height.
+  if (!isDecodedSizeAvailable()) {
+    // Protect against large PNGs. See http://bugzil.la/251381 for more details.
+    const unsigned long maxPNGSize = 1000000UL;
+    if (width > maxPNGSize || height > maxPNGSize) {
+      longjmp(JMPBUF(png), 1);
+      return;
+    }
+
+    // Set the image size now that the image header is available.
+    if (!setSize(width, height)) {
+      longjmp(JMPBUF(png), 1);
+      return;
+    }
+
+    if ((colorType & PNG_COLOR_MASK_COLOR) && !ignoresColorSpace()) {
+      // We only support color profiles for color PALETTE and RGB[A] PNG.
+      // TODO(msarret): Add GRAY profile support, block CYMK?
+      if (sk_sp<SkColorSpace> colorSpace = readColorSpace(png, info))
+        setEmbeddedColorSpace(colorSpace);
+    }
   }
 
   if (!hasEmbeddedColorSpace()) {
     const double inverseGamma = 0.45455;
     const double defaultGamma = 2.2;
     double gamma;
     if (!ignoresColorSpace() && png_get_gAMA(png, info, &gamma)) {
       const double maxGamma = 21474.83;
       if ((gamma <= 0.0) || (gamma > maxGamma)) {
         gamma = inverseGamma;
         png_set_gAMA(png, info, gamma);
       }
       png_set_gamma(png, defaultGamma, gamma);
     } else {
       png_set_gamma(png, defaultGamma, inverseGamma);
     }
   }
 
+  DCHECK(isDecodedSizeAvailable());
+
   // Tell libpng to send us rows for interlaced pngs.
   if (interlaceType == PNG_INTERLACE_ADAM7)
     png_set_interlace_handling(png);
 
   // Update our info now (so we can get color channel info).
   png_read_update_info(png, info);
 
   int channels = png_get_channels(png, info);
   DCHECK(channels == 3 || channels == 4);
-  m_reader->setHasAlpha(channels == 4);
-
-  if (m_reader->decodingSizeOnly()) {
-// If we only needed the size, halt the reader.
-#if PNG_LIBPNG_VER_MAJOR > 1 || \
-    (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)
-    // Passing '0' tells png_process_data_pause() not to cache unprocessed data.
-    m_reader->setReadOffset(m_reader->currentBufferSize() -
-                            png_process_data_pause(png, 0));
-#else
-    m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
-    png->buffer_size = 0;
-#endif
-  }
+  m_hasAlphaChannel = (channels == 4);
 }
 
 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer,
                                    unsigned rowIndex,
                                    int) {
-  if (m_frameBufferCache.isEmpty())
+  if (m_currentFrame >= m_frameBufferCache.size())
     return;
 
-  // Initialize the framebuffer if needed.
-  ImageFrame& buffer = m_frameBufferCache[0];
+  ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
   if (buffer.getStatus() == ImageFrame::FrameEmpty) {
     png_structp png = m_reader->pngPtr();
-    if (!buffer.setSizeAndColorSpace(size().width(), size().height(),
-                                     colorSpaceForSkImages())) {
+    if (!initFrameBuffer(m_currentFrame)) {
       longjmp(JMPBUF(png), 1);
       return;
     }
 
-    unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
+    DCHECK_EQ(ImageFrame::FramePartial, buffer.getStatus());
+
     if (PNG_INTERLACE_ADAM7 ==
         png_get_interlace_type(png, m_reader->infoPtr())) {
-      m_reader->createInterlaceBuffer(colorChannels * size().width() *
-                                      size().height());
+      unsigned colorChannels = m_hasAlphaChannel ? 4 : 3;
+      m_reader->createInterlaceBuffer(colorChannels * size().area());
       if (!m_reader->interlaceBuffer()) {
         longjmp(JMPBUF(png), 1);
         return;
       }
     }
 
-    buffer.setStatus(ImageFrame::FramePartial);
-    buffer.setHasAlpha(false);
+    m_currentBufferSawAlpha = false;
+  }
 
-    // For PNGs, the frame always fills the entire image.
-    buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
-  }
+  const IntRect& frameRect = buffer.originalFrameRect();
+  DCHECK(IntRect(IntPoint(), size()).contains(frameRect));
 
   /* libpng comments (here to explain what follows).
    *
    * this function is called for every row in the image. If the
    * image is interlacing, and you turned on the interlace handler,
    * this function will be called for every row in every pass.
    * Some of these rows will not be changed from the previous pass.
    * When the row is not changed, the new_row variable will be NULL.
    * The rows and passes are called in order, so you don't really
    * need the row_num and pass, but I'm supplying them because it
    * may make your life easier.
    */
 
-  // Nothing to do if the row is unchanged, or the row is outside
-  // the image bounds: libpng may send extra rows, ignore them to
-  // make our lives easier.
+  // Nothing to do if the row is unchanged, or the row is outside the image
+  // bounds. In the case that a frame presents more data than the indicated
+  // frame size, ignore the extra rows and use the frame size as the source
+  // of truth. libpng can send extra rows: ignore them too, this to prevent
+  // memory writes outside of the image bounds (security).
   if (!rowBuffer)
     return;
-  int y = rowIndex;
-  if (y < 0 || y >= size().height())
+
+  DCHECK_GT(frameRect.height(), 0);
+  if (rowIndex >= static_cast<unsigned>(frameRect.height()))
     return;
 
+  int y = rowIndex + frameRect.y();
+  if (y < 0)
+    return;
+  DCHECK_LT(y, size().height());
+
   /* libpng comments (continued).
    *
    * For the non-NULL rows of interlaced images, you must call
    * png_progressive_combine_row() passing in the row and the
    * old row.  You can call this function for NULL rows (it will
    * just return) and for non-interlaced images (it just does the
    * memcpy for you) if it will make the code easier. Thus, you
    * can just do this for all cases:
    *
    *    png_progressive_combine_row(png_ptr, old_row, new_row);
    *
    * where old_row is what was displayed for previous rows. Note
    * that the first pass (pass == 0 really) will completely cover
    * the old row, so the rows do not have to be initialized. After
    * the first pass (and only for interlaced images), you will have
    * to pass the current row, and the function will combine the
    * old row and the new row.
    */
 
-  bool hasAlpha = m_reader->hasAlpha();
+  bool hasAlpha = m_hasAlphaChannel;
   png_bytep row = rowBuffer;
 
   if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
     unsigned colorChannels = hasAlpha ? 4 : 3;
     row = interlaceBuffer + (rowIndex * colorChannels * size().width());
     png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
   }
 
   // Write the decoded row pixels to the frame buffer. The repetitive
   // form of the row write loops is for speed.
-  ImageFrame::PixelData* const dstRow = buffer.getAddr(0, y);
-  int width = size().width();
+  ImageFrame::PixelData* const dstRow = buffer.getAddr(frameRect.x(), y);
+  int width = frameRect.width();
 
   png_bytep srcPtr = row;
   if (hasAlpha) {
     // Here we apply the color space transformation to the dst space.
     // It does not really make sense to transform to a gamma-encoded
     // space and then immediately after, perform a linear premultiply.
     // Ideally we would pass kPremul_SkAlphaType to xform->apply(),
     // instructing SkColorSpaceXform to perform the linear premultiply
     // while the pixels are a linear space.
     // We cannot do this because when we apply the gamma encoding after
     // the premultiply, we will very likely end up with valid pixels
     // where R, G, and/or B are greater than A.  The legacy drawing
     // pipeline does not know how to handle this.
     if (SkColorSpaceXform* xform = colorTransform()) {
       SkColorSpaceXform::ColorFormat colorFormat =
           SkColorSpaceXform::kRGBA_8888_ColorFormat;
       xform->apply(colorFormat, dstRow, colorFormat, srcPtr, size().width(),
                    kUnpremul_SkAlphaType);
       srcPtr = png_bytep(dstRow);
     }
 
     unsigned alphaMask = 255;
-    if (buffer.premultiplyAlpha()) {
-      for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
-           srcPtr += 4, ++dstPixel) {
-        buffer.setRGBAPremultiply(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
-                                  srcPtr[3]);
-        alphaMask &= srcPtr[3];
+    if (m_frameBufferCache[m_currentFrame].getAlphaBlendSource() ==
+        ImageFrame::BlendAtopBgcolor) {
+      if (buffer.premultiplyAlpha()) {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.setRGBAPremultiply(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
+                                    srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
+      } else {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
+                            srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
       }
     } else {
-      for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
-           srcPtr += 4, ++dstPixel) {
-        buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], srcPtr[3]);
-        alphaMask &= srcPtr[3];
+      // Now, the blend method is ImageFrame::BlendAtopPreviousFrame. Since the
+      // frame data of the previous frame is copied at initFrameBuffer, we can
+      // blend the pixel of this frame, stored in |srcPtr|, over the previous
+      // pixel stored in |dstPixel|.
+      if (buffer.premultiplyAlpha()) {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.blendRGBAPremultiplied(dstPixel, srcPtr[0], srcPtr[1],
+                                        srcPtr[2], srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
+      } else {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.blendRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
+                              srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
       }
     }
 
-    if (alphaMask != 255 && !buffer.hasAlpha())
-      buffer.setHasAlpha(true);
+    if (alphaMask != 255)
+      m_currentBufferSawAlpha = true;
 
   } else {
     for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
          srcPtr += 3, ++dstPixel) {
       buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], 255);
     }
 
     // We'll apply the color space xform to opaque pixels after they have been
     // written to the ImageFrame, purely because SkColorSpaceXform supports
     // RGBA (and not RGB).
     if (SkColorSpaceXform* xform = colorTransform()) {
       xform->apply(xformColorFormat(), dstRow, xformColorFormat(), dstRow,
                    size().width(), kOpaque_SkAlphaType);
     }
   }
 
   buffer.setPixelsChanged(true);
 }
 
-void PNGImageDecoder::complete() {
-  if (m_frameBufferCache.isEmpty())
+void PNGImageDecoder::frameComplete() {
+  if (m_currentFrame >= m_frameBufferCache.size())
     return;
 
-  m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete);
+  if (m_reader->interlaceBuffer())
+    m_reader->clearInterlaceBuffer();
+
+  ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
+  if (buffer.getStatus() == ImageFrame::FrameEmpty) {
+    longjmp(JMPBUF(m_reader->pngPtr()), 1);
+    return;
+  }
+
+  if (!m_currentBufferSawAlpha)
+    correctAlphaWhenFrameBufferSawNoAlpha(m_currentFrame);
+
+  buffer.setStatus(ImageFrame::FrameComplete);
 }
 
-inline bool isComplete(const PNGImageDecoder* decoder) {
-  return decoder->frameIsCompleteAtIndex(0);
+bool PNGImageDecoder::frameIsCompleteAtIndex(size_t index) const {
+  if (!isDecodedSizeAvailable())
+    return false;
+
+  DCHECK(!failed() && m_reader);
+
+  // For non-animated images, return whether the status of the frame is
+  // ImageFrame::FrameComplete with ImageDecoder::frameIsCompleteAtIndex.
+  // This matches the behavior of WEBPImageDecoder.
+  if (m_reader->parseCompleted() && m_reader->frameCount() == 1)
+    return ImageDecoder::frameIsCompleteAtIndex(index);
+
+  // For first frames of animated images, PNGImageReader exposes whether it is
+  // fully received through firstFrameFullyReceived().
+  if (!index)

[Noel Gordon, 2017/03/08 16:26:14]

Seems fine.  Maybe in future we should get rid of the distinction b/w
firstFrameFullyReceived() for the first animated frame, and index <
m_reader->frameCount() for other animated frames, if that is possible.

[scroggo_chromium, 2017/03/08 20:53:22]

Not sure I follow you. Do you mean m_reader->frameCount() should return 0 until
we have fully received the first frame? I think that would prevent us from
progressively decoding frame 0 as it becomes available.

[Noel Gordon, 2017/03/13 12:16:17]

Not quite.
It would, but my question is about something else ...

firstFrameFullyReceived() seems to be a reflection of m_reader's internal magic
whereby it puts the first frame into FrameInfo[] _before it is fully received_.

If frames were only put into FrameInfo[] _when they were fully received_, for
all index >= 0, then index < m_reader->frameCount() would be enough to implement
frameIsCompleteAtIndex() for an APNG.  (This would require some re-org in the
way the reader's part of decoding works.  Not sure how easy it would be, but I'm
not asking you to do it now either, just a quibble from me about that aspect of
the design).

Anyho, consider adding a reader function frameIsReceivedAtIndex(index) for the
animated image case, and put the reader's special cases therein:

bool PNGImageReader::frameIsReceivedAtIndex(index) const {
  if (!index)
    return firstFrameFullyReceived();
  return index < m_reader->frameCount();
}

Next, since you had concerns about progressive decoding, could we add a test for
that in the animated image case please?  A bug about it would be enough.  You
would add a HTTP layout test using the load-and-stall script, see for example:

LayoutTests/http/tests/images/png-partial-load.html
LayoutTests/http/tests/images/jpeg-partial-load.html

Possible?

[scroggo_chromium, 2017/03/13 13:50:08]

Done.
Filed crbug.com/700892

+    return m_reader->firstFrameFullyReceived();
+
+  // Non-first frames are reported by |m_reader| once it has parsed all data
+  // for that frame, so return whether the index is below the reported frame
+  // count.
+  return index < m_reader->frameCount();
 }
 
-void PNGImageDecoder::decode(bool onlySize) {
-  if (failed())
-    return;
-
-  if (!m_reader)
-    m_reader = WTF::makeUnique<PNGImageReader>(this, m_offset);
-
-  // If we couldn't decode the image but have received all the data, decoding
-  // has failed.
-  if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
-    setFailed();
-
-  // If decoding is done or failed, we don't need the PNGImageReader anymore.
-  if (isComplete(this) || failed())
-    m_reader.reset();
+float PNGImageDecoder::frameDurationAtIndex(size_t index) const {
+  if (index < m_frameBufferCache.size())
+    return m_frameBufferCache[index].duration();
+  return 0;
 }
 
 }  // namespace blink