Animated PNG implementation

third_party/WebKit/Source/platform/image-decoders/png/PNGImageReader.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 34 matching lines @@
 class SegmentReader;
 
 class PLATFORM_EXPORT PNGImageReader final {
   USING_FAST_MALLOC(PNGImageReader);
   WTF_MAKE_NONCOPYABLE(PNGImageReader);
 
  public:
   PNGImageReader(PNGImageDecoder*, size_t offset);
   ~PNGImageReader();
 
-  bool decode(const SegmentReader&, bool sizeOnly);
+  struct FrameInfo {
+    size_t start;
+    size_t finish;
+    png_uint_32 width;
+    png_uint_32 height;
+    png_uint_32 xOffset;
+    png_uint_32 yOffset;
+    unsigned duration;
+    unsigned dispose;
+    unsigned blend;
+  };
+
+  inline void processData(const SegmentReader& data,
+                          size_t index,
+                          size_t offset,
+                          size_t endOffset) {
+    const char* segment;
+    while (size_t segmentLength = data.getSomeData(segment, offset)) {
+      if (endOffset && offset + segmentLength > endOffset)
+        segmentLength = endOffset - offset;
+
+      offset += segmentLength;
+      png_process_data(m_png, m_info,
+                       reinterpret_cast<png_bytep>(const_cast<char*>(segment)),
+                       segmentLength);
+
+      if (offset == endOffset)
+        break;
+    }
+    if (!index)
+      m_decodeOffset = offset;
+  }
+
+  bool parse(SegmentReader&);
+  bool decode(SegmentReader&, size_t index);
   png_structp pngPtr() const { return m_png; }
   png_infop infoPtr() const { return m_info; }
 
-  size_t getReadOffset() const { return m_readOffset; }
-  void setReadOffset(size_t offset) { m_readOffset = offset; }
-  size_t currentBufferSize() const { return m_currentBufferSize; }
-  bool decodingSizeOnly() const { return m_decodingSizeOnly; }
+  int repetitionCount() const { return m_repetitionCount; }
+  size_t imagesCount() const {
+    return m_frames.isEmpty() ? 1 : m_frames.size() - m_posterFrame;
+  }
+  const FrameInfo* frameInfo(size_t index) const {
+    return m_frames.isEmpty() ? &m_currentFrame
+                              : &m_frames[index + m_posterFrame];
+  }
   void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
   bool hasAlpha() const { return m_hasAlpha; }
 
   png_bytep interlaceBuffer() const { return m_interlaceBuffer.get(); }
   void createInterlaceBuffer(int size) {
     m_interlaceBuffer = wrapArrayUnique(new png_byte[size]);
   }
 
  private:
   png_structp m_png;
   png_infop m_info;
   PNGImageDecoder* m_decoder;
   size_t m_readOffset;
-  size_t m_currentBufferSize;
-  bool m_decodingSizeOnly;
+  size_t m_parseOffset;
+  size_t m_decodeOffset;
+  size_t m_infoSize;
+  bool m_isAnimated;
+  bool m_isParsed;
+  png_uint_32 m_width;
+  png_uint_32 m_height;
+  int m_repetitionCount;
+  size_t m_posterFrame;
+  size_t m_visibleFrames;
+  FrameInfo m_currentFrame;
+  Vector<FrameInfo> m_frames;
   bool m_hasAlpha;
   std::unique_ptr<png_byte[]> m_interlaceBuffer;
 };
 
 }  // namespace blink
 
 #endif