Merge pull request #25715 from sturkmen72:apng_support

Animated PNG Support #25715

Continues https://github.com/opencv/opencv/pull/25608

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake

modules/imgcodecs/src/grfmt_avif.cpp

@@ -243,7 +243,7 @@ bool AvifDecoder::readData(Mat &img) {
     return false;
   }
 
-  m_animation.durations.push_back(decoder_->imageTiming.durationInTimescales);
+  m_animation.durations.push_back(decoder_->imageTiming.duration * 1000);
 
   if (decoder_->image->exif.size > 0) {
     m_exif.parseExif(decoder_->image->exif.data, decoder_->image->exif.size);

modules/imgcodecs/src/grfmt_png.hpp

@@ -47,26 +47,98 @@
 
 #include "grfmt_base.hpp"
 #include "bitstrm.hpp"
+#include <png.h>
+#include <zlib.h>
 
 namespace cv
 {
 
+struct Chunk { unsigned char* p; uint32_t size; };
+struct OP { unsigned char* p; uint32_t size; int x, y, w, h, valid, filters; };
+
+typedef struct {
+  unsigned char r, g, b;
+} rgb;
+
+class APNGFrame {
+public:
+
+    APNGFrame();
+
+    // Destructor
+    ~APNGFrame();
+
+    bool setMat(const cv::Mat& src, unsigned delayNum = 1, unsigned delayDen = 1000);
+
+    // Getters and Setters
+    unsigned char* getPixels() const { return _pixels; }
+    void setPixels(unsigned char* pixels);
+
+    unsigned int getWidth() const { return _width; }
+    void setWidth(unsigned int width);
+
+    unsigned int getHeight() const { return _height; }
+    void setHeight(unsigned int height);
+
+    unsigned char getColorType() const { return _colorType; }
+    void setColorType(unsigned char colorType);
+
+    rgb* getPalette() { return _palette; }
+    void setPalette(const rgb* palette);
+
+    unsigned char* getTransparency() { return _transparency; }
+    void setTransparency(const unsigned char* transparency);
+
+    int getPaletteSize() const { return _paletteSize; }
+    void setPaletteSize(int paletteSize);
+
+    int getTransparencySize() const { return _transparencySize; }
+    void setTransparencySize(int transparencySize);
+
+    unsigned int getDelayNum() const { return _delayNum; }
+    void setDelayNum(unsigned int delayNum);
+
+    unsigned int getDelayDen() const { return _delayDen; }
+    void setDelayDen(unsigned int delayDen);
+
+    unsigned char** getRows() const { return _rows; }
+    void setRows(unsigned char** rows);
+
+private:
+    unsigned char* _pixels;
+    unsigned int _width;
+    unsigned int _height;
+    unsigned char _colorType;
+    rgb _palette[256];
+    unsigned char _transparency[256];
+    int _paletteSize;
+    int _transparencySize;
+    unsigned int _delayNum;
+    unsigned int _delayDen;
+    unsigned char** _rows;
+};
+
 class PngDecoder CV_FINAL : public BaseImageDecoder
 {
 public:
-
     PngDecoder();
     virtual ~PngDecoder();
 
     bool  readData( Mat& img ) CV_OVERRIDE;
     bool  readHeader() CV_OVERRIDE;
-    void  close();
+    bool  nextPage() CV_OVERRIDE;
 
     ImageDecoder newDecoder() const CV_OVERRIDE;
 
 protected:
-
     static void readDataFromBuf(void* png_ptr, uchar* dst, size_t size);
+    static void info_fn(png_structp png_ptr, png_infop info_ptr);
+    static void row_fn(png_structp png_ptr, png_bytep new_row, png_uint_32 row_num, int pass);
+    bool processing_start(void* frame_ptr, const Mat& img);
+    bool processing_finish();
+    void compose_frame(unsigned char** rows_dst, unsigned char** rows_src, unsigned char bop, uint32_t x, uint32_t y, uint32_t w, uint32_t h, int channels);
+    size_t read_from_io(void* _Buffer, size_t _ElementSize, size_t _ElementCount);
+    uint32_t  read_chunk(Chunk& chunk);
 
     int   m_bit_depth;
     void* m_png_ptr;  // pointer to decompression structure
@@ -74,7 +146,25 @@ protected:
     void* m_end_info; // pointer to one more image information structure
     FILE* m_f;
     int   m_color_type;
+    Chunk m_chunkIHDR;
+    int   m_frame_no;
     size_t m_buf_pos;
+    std::vector<Chunk> m_chunksInfo;
+    APNGFrame frameRaw;
+    APNGFrame frameNext;
+    APNGFrame frameCur;
+    Mat m_mat_raw;
+    Mat m_mat_next;
+    uint32_t w0;
+    uint32_t h0;
+    uint32_t x0;
+    uint32_t y0;
+    uint32_t delay_num;
+    uint32_t delay_den;
+    uint32_t dop;
+    uint32_t bop;
+    bool m_is_fcTL_loaded;
+    bool m_is_IDAT_loaded;
 };
 
 
@@ -84,14 +174,40 @@ public:
     PngEncoder();
     virtual ~PngEncoder();
 
-    bool  isFormatSupported( int depth ) const CV_OVERRIDE;
-    bool  write( const Mat& img, const std::vector<int>& params ) CV_OVERRIDE;
+    bool isFormatSupported( int depth ) const CV_OVERRIDE;
+    bool write( const Mat& img, const std::vector<int>& params ) CV_OVERRIDE;
+    bool writemulti(const std::vector<Mat>& img_vec, const std::vector<int>& params) CV_OVERRIDE;
+    bool writeanimation(const Animation& animinfo, const std::vector<int>& params) CV_OVERRIDE;
 
     ImageEncoder newEncoder() const CV_OVERRIDE;
 
 protected:
-    static void writeDataToBuf(void* png_ptr, uchar* src, size_t size);
+    static void writeDataToBuf(void* png_ptr, unsigned char* src, size_t size);
     static void flushBuf(void* png_ptr);
+    size_t write_to_io(void const* _Buffer, size_t  _ElementSize, size_t _ElementCount, FILE* _Stream);
+
+private:
+    void writeChunk(FILE* f, const char* name, unsigned char* data, uint32_t length);
+    void writeIDATs(FILE* f, int frame, unsigned char* data, uint32_t length, uint32_t idat_size);
+    void processRect(unsigned char* row, int rowbytes, int bpp, int stride, int h, unsigned char* rows);
+    void deflateRectFin(unsigned char* zbuf, uint32_t* zsize, int bpp, int stride, unsigned char* rows, int zbuf_size, int n);
+    void deflateRectOp(unsigned char* pdata, int x, int y, int w, int h, int bpp, int stride, int zbuf_size, int n);
+    bool getRect(uint32_t w, uint32_t h, unsigned char* pimage1, unsigned char* pimage2, unsigned char* ptemp, uint32_t bpp, uint32_t stride, int zbuf_size, uint32_t has_tcolor, uint32_t tcolor, int n);
+
+    AutoBuffer<unsigned char> op_zbuf1;
+    AutoBuffer<unsigned char> op_zbuf2;
+    AutoBuffer<unsigned char> row_buf;
+    AutoBuffer<unsigned char> sub_row;
+    AutoBuffer<unsigned char> up_row;
+    AutoBuffer<unsigned char> avg_row;
+    AutoBuffer<unsigned char> paeth_row;
+    z_stream       op_zstream1;
+    z_stream       op_zstream2;
+    OP             op[6];
+    rgb            palette[256];
+    unsigned char  trns[256];
+    uint32_t       palsize, trnssize;
+    uint32_t       next_seq_num;
 };
 
 }

modules/imgcodecs/src/loadsave.cpp

@@ -776,7 +776,8 @@ imreadanimation_(const String& filename, int flags, int start, int count, Animat
 
         if (current >= start)
         {
-            animation.durations.push_back(decoder->animation().durations[decoder->animation().durations.size() - 1]);
+            int duration = decoder->animation().durations.size() > 0 ? decoder->animation().durations.back() : 1000;
+            animation.durations.push_back(duration);
             animation.frames.push_back(mat);
         }