WIP: Implement APNG

third_party/WebKit/Source/platform/image-decoders/png/PNGImageDecoder.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 26 matching lines @@
   WTF_MAKE_NONCOPYABLE(PNGImageDecoder);
 
  public:
   PNGImageDecoder(AlphaOption,
                   ColorSpaceOption,
                   sk_sp<SkColorSpace>,
                   size_t maxDecodedBytes,
                   size_t offset = 0);
   ~PNGImageDecoder() override;
 
+  enum class PNGParseQuery { PNGSizeQuery, PNGMetaDataQuery };
+
   // ImageDecoder:
   String filenameExtension() const override { return "png"; }
+  int repetitionCount() const override;
+  bool frameIsCompleteAtIndex(size_t) const override;
+  float frameDurationAtIndex(size_t) const override;
+  // Failures are handled differently, based on the image and state of the
+  // decoder:
+  //
+  // 1) When a non-animated PNG or the first frame of an animated PNG can't be
+  //    decoded or parsed, set the decoder to the failed state, because there
+  //    are no frames we can show to the client. Also set the state to failed if
+  //    a parse error occurs before any frames were received.
+  // 2) When a decoding failure occurs for non-first frames, we still want to
+  //    show earlier frames. This means the frame count needs to be adjusted.
+  // 3) When a parsing failure occurs, the frame count is adjusted to the number
+  //    of successfully parsed frames, since we can still show those.
+  //
+  // In cases 2 and 3, we have to prevent parse() from adjusting the frame
+  // count to pre-failure values by setting |m_failedWithCorrectFrames| to true.
+  bool setFailed() override;
 
   // Callbacks from libpng
   void headerAvailable();
   void rowAvailable(unsigned char* row, unsigned rowIndex, int);
   void complete();
 
+  // Additional methods used for APNG
+  void setRepetitionCount(size_t);
+
  private:
   // ImageDecoder:
-  void decodeSize() override { decode(true); }
-  void decode(size_t) override { decode(false); }
+  void decodeSize() override { parse(PNGParseQuery::PNGSizeQuery); }
+  void decode(size_t) override;
+  size_t decodeFrameCount() override;
+  void initializeNewFrame(size_t) override;
+  void clearFrameBuffer(size_t) override;
 
-  // Decodes the image.  If |onlySize| is true, stops decoding after
-  // calculating the image size.  If decoding fails but there is no more
-  // data coming, sets the "decode failure" flag.
-  void decode(bool onlySize);
+  // Create an interlacing buffer when the frame is encoded with interlacing.
+  void onInitFrameBuffer(size_t) override;
+
+  // When the disposal method of the frame is DisposeOverwritePrevious, the

[scroggo_chromium, 2016/12/07 13:44:44]

Is this not already explained in the base class? Clients won't call this method
directly, so I don't think the explanation is necessary here.

[joostouwerling, 2016/12/07 16:49:10]

The base class explains how this method is used (i.e. by initFrameBuffer to
determine if it can be taken over), and this comment explains why this condition
is as it is for APNG. I think that adds value.

+  // next frame will use the previous frame's buffer as its starting state, so
+  // we can't take over the data in that case. Before calling this method, the
+  // caller must verify that the frame exists.
+  bool canReusePreviousFrameBuffer(size_t index) const override;
+
+  void parse(PNGParseQuery);
+  // Used by clearCacheExceptFrame if two frames need to be kept in cache.
+  size_t clearCacheExceptTwoFrames(size_t, size_t);

[scroggo_chromium, 2016/12/07 13:44:44]

I thought this was moved to the base class?

[joostouwerling, 2016/12/07 16:49:10]

Yes. Removed it.

 
   std::unique_ptr<PNGImageReader> m_reader;
   const unsigned m_offset;
+  size_t m_frameCount;
+  size_t m_currentFrame;
+  // m_repetitionCount is set to cAnimationLoopOnce by default, so the
+  // DeferredImageDecoder takes into account that this may be an animated
+  // image, but we don't know for sure yet.
+  int m_repetitionCount;
+  bool m_hasAlphaChannel;
+  bool m_currentBufferSawAlpha;
+
+  // This flag is set to true while PNGImageReader is parsing. This is used by
+  // setFailed() to determine how to handle a failure.
+  bool m_isParsing;
+  // This flag is set to true when a failure has occured, but there are earlier
+  // frames that can still be shown. In that case, the frame count is lowered.
+  // This flag prevents from calling parse() again, which could change the frame

[scroggo_chromium, 2016/12/07 13:44:44]

What if instead we set the reader's m_parseCompleted to true? Then do we still
need this variable?

[joostouwerling, 2016/12/07 16:49:10]

That'd work for parsing errors, but not for decoding errors, since
parseCompleted may already be true at that point.

Edit: if the check for parseCompleted() is moved to the first line of
PNGImageDecoder::parse(), it'll work. What we try to prevent is getting to is
  
  else if (query == PNGParseQuery::PNGMetaDataQuery)                            
    m_frameCount = m_reader->frameCount();

and if we'd return already at the beginning of parse(), that'll be avoided.

+  // count back to the pre-failure value.
+  bool m_failedWithCorrectFrames;
 };
 
 }  // namespace blink
 
 #endif