From 6fb68f67a0fab0cdd9ffa61329ed09939fe1bb31 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 24 Aug 2026 15:31:24 +0000
Subject: [PATCH 1/2] Add SVE2 optimizations of ImagePngSaver.

Implement SVE2 PNG filter encoding, Adler-32, and zlib match counting
for ImagePngSaver, wire it into ImageSaveToMemory, extend save tests
for unaligned PNG sizes, and note the change in release 7.2.165.

Co-authored-by: igor.ermolaev <igor.ermolaev@altezza.org>
---
 docs/2026.html                    |   2 +
 prj/vs2022/Sve2.vcxproj           |   3 +
 prj/vs2022/Sve2.vcxproj.filters   |   9 +
 src/Simd/SimdImageSave.h          |   6 +
 src/Simd/SimdImageSavePng.h       |  30 ++-
 src/Simd/SimdSve2ImageSave.cpp    |   2 +-
 src/Simd/SimdSve2ImageSavePng.cpp | 421 ++++++++++++++++++++++++++++++
 src/Test/TestImageIO.cpp          |  13 +
 8 files changed, 484 insertions(+), 2 deletions(-)
 create mode 100644 src/Simd/SimdSve2ImageSavePng.cpp

diff --git a/docs/2026.html b/docs/2026.html
index 6c298e28b6..54f7b77a66 100644
--- a/docs/2026.html
+++ b/docs/2026.html
@@ -78,6 +78,7 @@ <h5>New features</h5>
  <li>SVE2 optimizations of class ImagePpmTxtSaver.</li>
  <li>SVE2 optimizations of class ImagePpmBinSaver.</li>
  <li>SVE2 optimizations of class ImageBmpSaver.</li>
+ <li>SVE2 optimizations of class ImagePngSaver.</li>
  <li>C++ wrapper Simd::SynetAdd16b.</li>
  <li>C++ wrapper Simd::SynetQuantizedAdd.</li>
  <li>C++ wrapper Simd::SynetQuantizedMul.</li>
@@ -148,6 +149,7 @@ <h5>New features</h5>
  <li>Tests for verifying functionality of SVE2 optimizations of class ImagePgmBinSaver.</li>
  <li>Tests for verifying functionality of SVE2 optimizations of class ImagePpmTxtSaver.</li>
  <li>Tests for verifying functionality of SVE2 optimizations of class ImagePpmBinSaver.</li>
+ <li>Tests for verifying functionality of SVE2 optimizations of class ImagePngSaver.</li>
 </ul>
 <h5>Removing</h5>
 <ul>
diff --git a/prj/vs2022/Sve2.vcxproj b/prj/vs2022/Sve2.vcxproj
index 7c92773673..ddbacd22d9 100644
--- a/prj/vs2022/Sve2.vcxproj
+++ b/prj/vs2022/Sve2.vcxproj
@@ -71,6 +71,7 @@
     <ClCompile Include="..\..\src\Simd\SimdSve2Histogram.cpp" />
     <ClCompile Include="..\..\src\Simd\SimdSve2Hog.cpp" />
     <ClCompile Include="..\..\src\Simd\SimdSve2ImageSave.cpp" />
+    <ClCompile Include="..\..\src\Simd\SimdSve2ImageSavePng.cpp" />
     <ClCompile Include="..\..\src\Simd\SimdSve2Laplace.cpp" />
     <ClCompile Include="..\..\src\Simd\SimdSve2Lbp.cpp" />
     <ClCompile Include="..\..\src\Simd\SimdSve2MaxFilter.cpp" />
@@ -211,6 +212,8 @@
     <ClInclude Include="..\..\src\Simd\SimdDescrIntCommon.h" />
     <ClInclude Include="..\..\src\Simd\SimdEnable.h" />
     <ClInclude Include="..\..\src\Simd\SimdExtract.h" />
+    <ClInclude Include="..\..\src\Simd\SimdImageSave.h" />
+    <ClInclude Include="..\..\src\Simd\SimdImageSavePng.h" />
     <ClInclude Include="..\..\src\Simd\SimdInit.h" />
     <ClInclude Include="..\..\src\Simd\SimdLib.h" />
     <ClInclude Include="..\..\src\Simd\SimdLoad.h" />
diff --git a/prj/vs2022/Sve2.vcxproj.filters b/prj/vs2022/Sve2.vcxproj.filters
index bff68fdd00..485abea1df 100644
--- a/prj/vs2022/Sve2.vcxproj.filters
+++ b/prj/vs2022/Sve2.vcxproj.filters
@@ -129,6 +129,12 @@
     <ClInclude Include="..\..\src\Simd\SimdExtract.h">
       <Filter>Inc</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\src\Simd\SimdImageSave.h">
+      <Filter>Inc</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Simd\SimdImageSavePng.h">
+      <Filter>Inc</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\src\Simd\SimdInit.h">
       <Filter>Inc</Filter>
     </ClInclude>
@@ -311,6 +317,9 @@
     <ClCompile Include="..\..\src\Simd\SimdSve2ImageSave.cpp">
       <Filter>Sve2\Image</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\Simd\SimdSve2ImageSavePng.cpp">
+      <Filter>Sve2\Image</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\src\Simd\SimdSve2Laplace.cpp">
       <Filter>Sve2\Filter</Filter>
     </ClCompile>
diff --git a/src/Simd/SimdImageSave.h b/src/Simd/SimdImageSave.h
index e327f1f3ea..78008a2a0e 100644
--- a/src/Simd/SimdImageSave.h
+++ b/src/Simd/SimdImageSave.h
@@ -525,6 +525,12 @@ namespace Simd
             ImageBmpSaver(const ImageSaverParam& param);
         };
 
+        class ImagePngSaver : public Neon::ImagePngSaver
+        {
+        public:
+            ImagePngSaver(const ImageSaverParam& param);
+        };
+
         //-------------------------------------------------------------------------------------------------
 
         uint8_t* ImageSaveToMemory(const uint8_t* src, size_t stride, size_t width, size_t height, SimdPixelFormatType format, SimdImageFileType file, int quality, size_t* size);
diff --git a/src/Simd/SimdImageSavePng.h b/src/Simd/SimdImageSavePng.h
index 7b3f51d34b..4e9f71366b 100644
--- a/src/Simd/SimdImageSavePng.h
+++ b/src/Simd/SimdImageSavePng.h
@@ -121,7 +121,7 @@ namespace Simd
         {
             limit = Min(limit, 258);
             int i = 0;
-#if defined(SIMD_X64_ENABLE) || defined(SIMD_ARM64_ENABLE) || defined(SIMD_RISCV64_ENABLE)
+#if defined(SIMD_X64_ENABLE) || defined(SIMD_ARM64_ENABLE) || defined(SIMD_RISCV64_ENABLE)
             int limit8 = limit & (~7);
             for (; i < limit8; i += 8)
                 if (*(uint64_t*)(a + i) != *(uint64_t*)(b + i))
@@ -230,6 +230,34 @@ namespace Simd
     {
     }
 #endif// SIMD_NEON_ENABLE
+
+#ifdef SIMD_SVE2_ENABLE
+    namespace Sve2
+    {
+        SIMD_INLINE int ZlibCount(const uint8_t* a, const uint8_t* b, int limit)
+        {
+            limit = Min(limit, 258);
+            int i = 0;
+            const uint64_t A = svcntb();
+            const svbool_t body = svptrue_b8();
+            for (; i + (int)A <= limit; i += (int)A)
+            {
+                svbool_t ne = svcmpne_u8(body, svld1_u8(body, a + i), svld1_u8(body, b + i));
+                if (svptest_any(body, ne))
+                    return i + (int)svminv_u8(ne, svindex_u8(0, 1));
+            }
+            if (i < limit)
+            {
+                svbool_t tail = svwhilelt_b8((uint64_t)i, (uint64_t)limit);
+                svbool_t ne = svcmpne_u8(tail, svld1_u8(tail, a + i), svld1_u8(tail, b + i));
+                if (svptest_any(tail, ne))
+                    return i + (int)svminv_u8(ne, svindex_u8(0, 1));
+                i = limit;
+            }
+            return i;
+        }
+    }
+#endif// SIMD_SVE2_ENABLE
 }
 
 #endif//__SimdImageSavePng_h__
diff --git a/src/Simd/SimdSve2ImageSave.cpp b/src/Simd/SimdSve2ImageSave.cpp
index a6dbf0b21f..de89eb31d0 100644
--- a/src/Simd/SimdSve2ImageSave.cpp
+++ b/src/Simd/SimdSve2ImageSave.cpp
@@ -122,7 +122,7 @@ namespace Simd
             case SimdImageFilePgmBin: return new ImagePgmBinSaver(param);
             case SimdImageFilePpmTxt: return new ImagePpmTxtSaver(param);
             case SimdImageFilePpmBin: return new ImagePpmBinSaver(param);
-            case SimdImageFilePng: return new Neon::ImagePngSaver(param);
+            case SimdImageFilePng: return new ImagePngSaver(param);
             case SimdImageFileJpeg: return new Neon::ImageJpegSaver(param);
             case SimdImageFileBmp: return new ImageBmpSaver(param);
             default:
diff --git a/src/Simd/SimdSve2ImageSavePng.cpp b/src/Simd/SimdSve2ImageSavePng.cpp
new file mode 100644
index 0000000000..6a342b0585
--- /dev/null
+++ b/src/Simd/SimdSve2ImageSavePng.cpp
@@ -0,0 +1,421 @@
+/*
+* Simd Library (http://ermig1979.github.io/Simd).
+*
+* Copyright (c) 2011-2026 Yermalayeu Ihar.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*/
+#include "Simd/SimdMemory.h"
+#include "Simd/SimdImageSave.h"
+#include "Simd/SimdImageSavePng.h"
+#include "Simd/SimdBase.h"
+#include "Simd/SimdSve2.h"
+
+namespace Simd
+{
+#ifdef SIMD_SVE2_ENABLE
+    namespace Sve2
+    {
+        SIMD_INLINE void AddAbsSum(const svint8_t& value, const svbool_t& mask, const svuint8_t& ones, const svuint8_t& zero, svuint32_t& sum)
+        {
+            svuint8_t abs8 = svreinterpret_u8(svabs_s8_x(mask, value));
+            sum = svdot_u32(sum, svsel_u8(mask, abs8, zero), ones);
+        }
+
+        SIMD_INLINE svuint8_t PackU16(const svuint16_t& lo, const svuint16_t& hi)
+        {
+            return svuzp1_u8(svreinterpret_u8(lo), svreinterpret_u8(hi));
+        }
+
+        uint32_t ZlibAdler32(uint8_t* data, int size)
+        {
+            const size_t N = svcntw();
+            uint32_t lo = 1, hi = 0;
+            for (int b = 0, n = (int)(size % 5552); b < size;)
+            {
+                svuint32_t _l = svdup_n_u32(0), _h = svdup_n_u32(0);
+                int i = 0;
+                for (; i < n; i += (int)N)
+                {
+                    svbool_t mask = svwhilelt_b32((uint64_t)i, (uint64_t)n);
+                    svuint32_t d = svld1ub_u32(mask, data + b + i);
+                    svuint32_t w = svreinterpret_u32(svindex_s32((int32_t)(n - i), -1));
+                    _l = svadd_u32_m(mask, _l, d);
+                    _h = svmla_u32_m(mask, _h, d, w);
+                }
+                uint32_t l = svaddv_u32(svptrue_b32(), _l);
+                uint32_t h = svaddv_u32(svptrue_b32(), _h);
+                hi = (hi + h + lo * n) % 65521;
+                lo = (lo + l) % 65521;
+                b += n;
+                n = 5552;
+            }
+            return (hi << 16) | lo;
+        }
+
+        void ZlibCompress(uint8_t* data, int size, int quality, OutputMemoryStream& stream)
+        {
+            const int ZHASH = 16384;
+            if (quality < 5)
+                quality = 5;
+            const int basket = quality * 2;
+            Array32i hashTable(ZHASH * basket);
+            memset(hashTable.data, -1, hashTable.RawSize());
+
+            stream.Write(uint8_t(0x78));
+            stream.Write(uint8_t(0x5e));
+            stream.WriteBits(1, 1);
+            stream.WriteBits(1, 2);
+
+            int i = 0, j;
+            while (i < size - 3)
+            {
+                int h = Base::ZlibHash(data + i) & (ZHASH - 1), best = 3;
+                uint8_t* bestLoc = 0;
+                int* hList = hashTable.data + h * basket;
+                for (j = 0; hList[j] != -1 && j < basket; ++j)
+                {
+                    if (hList[j] > i - 32768)
+                    {
+                        int d = ZlibCount(data + hList[j], data + i, size - i);
+                        if (d >= best)
+                        {
+                            best = d;
+                            bestLoc = data + hList[j];
+                        }
+                    }
+                }
+                if (j == basket)
+                {
+                    memcpy(hList, hList + quality, quality * sizeof(int));
+                    memset(hList + quality, -1, quality * sizeof(int));
+                    j = quality;
+                }
+                hList[j] = i;
+
+                if (bestLoc)
+                {
+                    h = Base::ZlibHash(data + i + 1) & (ZHASH - 1);
+                    int* hList = hashTable.data + h * basket;
+                    for (j = 0; hList[j] != -1 && j < basket; ++j)
+                    {
+                        if (hList[j] > i - 32767)
+                        {
+                            int e = ZlibCount(data + hList[j], data + i + 1, size - i - 1);
+                            if (e > best)
+                            {
+                                bestLoc = NULL;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                if (bestLoc)
+                {
+                    int d = (int)(data + i - bestLoc);
+                    assert(d <= 32767 && best <= 258);
+                    for (j = 0; best > Base::ZlibLenC[j + 1] - 1; ++j);
+                    Base::ZlibHuff(j + 257, stream);
+                    if (Base::ZlibLenEb[j])
+                        stream.WriteBits(best - Base::ZlibLenC[j], Base::ZlibLenEb[j]);
+                    for (j = 0; d > Base::ZlibDistC[j + 1] - 1; ++j);
+                    stream.WriteBits(Base::ZlibBitRev(j, 5), 5);
+                    if (Base::ZlibDistEb[j])
+                        stream.WriteBits(d - Base::ZlibDistC[j], Base::ZlibDistEb[j]);
+                    i += best;
+                }
+                else
+                {
+                    Base::ZlibHuffB(data[i], stream);
+                    ++i;
+                }
+            }
+            for (; i < size; ++i)
+                Base::ZlibHuffB(data[i], stream);
+            Base::ZlibHuff(256, stream);
+            stream.FlushBits();
+            stream.WriteBe32u(ZlibAdler32(data, size));
+        }
+
+        uint32_t EncodeLine0(const uint8_t* src, size_t stride, size_t n, size_t size, int8_t* dst)
+        {
+            const size_t A = svcntb();
+            const size_t sizeA = AlignLo(size, A);
+            const svbool_t body = svptrue_b8();
+            const svuint8_t ones = svdup_n_u8(1);
+            const svuint8_t zero = svdup_n_u8(0);
+            svuint32_t sum = svdup_n_u32(0);
+            size_t i = 0;
+            for (; i < sizeA; i += A)
+            {
+                svint8_t _src = svreinterpret_s8(svld1_u8(body, src + i));
+                svst1_s8(body, dst + i, _src);
+                AddAbsSum(_src, body, ones, zero, sum);
+            }
+            if (sizeA < size)
+            {
+                svbool_t tail = svwhilelt_b8(sizeA, size);
+                svint8_t _src = svreinterpret_s8(svld1_u8(tail, src + i));
+                svst1_s8(tail, dst + i, _src);
+                AddAbsSum(_src, tail, ones, zero, sum);
+            }
+            return svaddv_u32(svptrue_b32(), sum);
+        }
+
+        uint32_t EncodeLine1(const uint8_t* src, size_t stride, size_t n, size_t size, int8_t* dst)
+        {
+            const size_t A = svcntb();
+            const size_t sizeA = AlignLo(size - n, A) + n;
+            const svbool_t body = svptrue_b8();
+            const svuint8_t ones = svdup_n_u8(1);
+            const svuint8_t zero = svdup_n_u8(0);
+            uint32_t sum = 0;
+            size_t i = 0;
+            for (; i < n; ++i)
+            {
+                dst[i] = src[i];
+                sum += ::abs(dst[i]);
+            }
+            svuint32_t _sum = svdup_n_u32(0);
+            for (; i < sizeA; i += A)
+            {
+                svint8_t _dst = svsub_s8_x(body, svreinterpret_s8(svld1_u8(body, src + i)), svreinterpret_s8(svld1_u8(body, src + i - n)));
+                svst1_s8(body, dst + i, _dst);
+                AddAbsSum(_dst, body, ones, zero, _sum);
+            }
+            if (i < size)
+            {
+                svbool_t tail = svwhilelt_b8(i, size);
+                svint8_t _dst = svsub_s8_x(tail, svreinterpret_s8(svld1_u8(tail, src + i)), svreinterpret_s8(svld1_u8(tail, src + i - n)));
+                svst1_s8(tail, dst + i, _dst);
+                AddAbsSum(_dst, tail, ones, zero, _sum);
+            }
+            return sum + svaddv_u32(svptrue_b32(), _sum);
+        }
+
+        uint32_t EncodeLine2(const uint8_t* src, size_t stride, size_t n, size_t size, int8_t* dst)
+        {
+            const size_t A = svcntb();
+            const size_t sizeA = AlignLo(size - n, A) + n;
+            const svbool_t body = svptrue_b8();
+            const svuint8_t ones = svdup_n_u8(1);
+            const svuint8_t zero = svdup_n_u8(0);
+            uint32_t sum = 0;
+            size_t i = 0;
+            for (; i < n; ++i)
+            {
+                dst[i] = src[i] - src[i - stride];
+                sum += ::abs(dst[i]);
+            }
+            svuint32_t _sum = svdup_n_u32(0);
+            for (; i < sizeA; i += A)
+            {
+                svint8_t _dst = svsub_s8_x(body, svreinterpret_s8(svld1_u8(body, src + i)), svreinterpret_s8(svld1_u8(body, src + i - stride)));
+                svst1_s8(body, dst + i, _dst);
+                AddAbsSum(_dst, body, ones, zero, _sum);
+            }
+            if (i < size)
+            {
+                svbool_t tail = svwhilelt_b8(i, size);
+                svint8_t _dst = svsub_s8_x(tail, svreinterpret_s8(svld1_u8(tail, src + i)), svreinterpret_s8(svld1_u8(tail, src + i - stride)));
+                svst1_s8(tail, dst + i, _dst);
+                AddAbsSum(_dst, tail, ones, zero, _sum);
+            }
+            return sum + svaddv_u32(svptrue_b32(), _sum);
+        }
+
+        uint32_t EncodeLine3(const uint8_t* src, size_t stride, size_t n, size_t size, int8_t* dst)
+        {
+            const size_t A = svcntb();
+            const size_t sizeA = AlignLo(size - n, A) + n;
+            const svbool_t body = svptrue_b8();
+            const svuint8_t ones = svdup_n_u8(1);
+            const svuint8_t zero = svdup_n_u8(0);
+            uint32_t sum = 0;
+            size_t i = 0;
+            for (; i < n; ++i)
+            {
+                dst[i] = src[i] - (src[i - stride] >> 1);
+                sum += ::abs(dst[i]);
+            }
+            svuint32_t _sum = svdup_n_u32(0);
+            for (; i < sizeA; i += A)
+            {
+                svuint8_t _src0 = svld1_u8(body, src + i);
+                svuint8_t avg = svhadd_u8_x(body, svld1_u8(body, src + i - n), svld1_u8(body, src + i - stride));
+                svint8_t _dst = svreinterpret_s8(svsub_u8_x(body, _src0, avg));
+                svst1_s8(body, dst + i, _dst);
+                AddAbsSum(_dst, body, ones, zero, _sum);
+            }
+            if (i < size)
+            {
+                svbool_t tail = svwhilelt_b8(i, size);
+                svuint8_t _src0 = svld1_u8(tail, src + i);
+                svuint8_t avg = svhadd_u8_x(tail, svld1_u8(tail, src + i - n), svld1_u8(tail, src + i - stride));
+                svint8_t _dst = svreinterpret_s8(svsub_u8_x(tail, _src0, avg));
+                svst1_s8(tail, dst + i, _dst);
+                AddAbsSum(_dst, tail, ones, zero, _sum);
+            }
+            return sum + svaddv_u32(svptrue_b32(), _sum);
+        }
+
+        SIMD_INLINE svuint16_t Paeth(const svuint16_t& a, const svuint16_t& b, const svuint16_t& c, const svbool_t& mask)
+        {
+            svint16_t _a = svreinterpret_s16(a);
+            svint16_t _b = svreinterpret_s16(b);
+            svint16_t _c = svreinterpret_s16(c);
+            svint16_t p = svsub_s16_x(mask, svadd_s16_x(mask, _a, _b), _c);
+            svint16_t pa = svabs_s16_x(mask, svsub_s16_x(mask, p, _a));
+            svint16_t pb = svabs_s16_x(mask, svsub_s16_x(mask, p, _b));
+            svint16_t pc = svabs_s16_x(mask, svsub_s16_x(mask, p, _c));
+            svbool_t mbc = svorr_b_z(mask, svcmpgt_s16(mask, pa, pb), svcmpgt_s16(mask, pa, pc));
+            svbool_t mc = svcmpgt_s16(mask, pb, pc);
+            return svsel_u16(mbc, svsel_u16(mc, c, b), a);
+        }
+
+        uint32_t EncodeLine4(const uint8_t* src, size_t stride, size_t n, size_t size, int8_t* dst)
+        {
+            const size_t A = svcntb();
+            const size_t sizeA = AlignLo(size - n, A) + n;
+            const svbool_t body = svptrue_b8();
+            const svbool_t body16 = svptrue_b16();
+            const svuint8_t ones = svdup_n_u8(1);
+            const svuint8_t zero = svdup_n_u8(0);
+            uint32_t sum = 0;
+            size_t i = 0;
+            for (; i < n; ++i)
+            {
+                dst[i] = (int8_t)(src[i] - src[i - stride]);
+                sum += ::abs(dst[i]);
+            }
+            svuint32_t _sum = svdup_n_u32(0);
+            for (; i < sizeA; i += A)
+            {
+                svuint8_t _src0 = svld1_u8(body, src + i);
+                svuint8_t _src1 = svld1_u8(body, src + i - n);
+                svuint8_t _src2 = svld1_u8(body, src + i - stride);
+                svuint8_t _src3 = svld1_u8(body, src + i - stride - n);
+                svuint16_t lo = Paeth(svunpklo_u16(_src1), svunpklo_u16(_src2), svunpklo_u16(_src3), body16);
+                svuint16_t hi = Paeth(svunpkhi_u16(_src1), svunpkhi_u16(_src2), svunpkhi_u16(_src3), body16);
+                svint8_t _dst = svreinterpret_s8(svsub_u8_x(body, _src0, PackU16(lo, hi)));
+                svst1_s8(body, dst + i, _dst);
+                AddAbsSum(_dst, body, ones, zero, _sum);
+            }
+            if (i < size)
+            {
+                svbool_t tail = svwhilelt_b8(i, size);
+                svuint8_t _src0 = svld1_u8(tail, src + i);
+                svuint8_t _src1 = svld1_u8(tail, src + i - n);
+                svuint8_t _src2 = svld1_u8(tail, src + i - stride);
+                svuint8_t _src3 = svld1_u8(tail, src + i - stride - n);
+                svuint16_t lo = Paeth(svunpklo_u16(_src1), svunpklo_u16(_src2), svunpklo_u16(_src3), body16);
+                svuint16_t hi = Paeth(svunpkhi_u16(_src1), svunpkhi_u16(_src2), svunpkhi_u16(_src3), body16);
+                svint8_t _dst = svreinterpret_s8(svsub_u8_x(tail, _src0, PackU16(lo, hi)));
+                svst1_s8(tail, dst + i, _dst);
+                AddAbsSum(_dst, tail, ones, zero, _sum);
+            }
+            return sum + svaddv_u32(svptrue_b32(), _sum);
+        }
+
+        uint32_t EncodeLine5(const uint8_t* src, size_t stride, size_t n, size_t size, int8_t* dst)
+        {
+            const size_t A = svcntb();
+            const size_t sizeA = AlignLo(size - n, A) + n;
+            const svbool_t body = svptrue_b8();
+            const svuint8_t ones = svdup_n_u8(1);
+            const svuint8_t zero = svdup_n_u8(0);
+            uint32_t sum = 0;
+            size_t i = 0;
+            for (; i < n; ++i)
+            {
+                dst[i] = src[i];
+                sum += ::abs(dst[i]);
+            }
+            svuint32_t _sum = svdup_n_u32(0);
+            for (; i < sizeA; i += A)
+            {
+                svuint8_t _src0 = svld1_u8(body, src + i);
+                svuint8_t half = svlsr_n_u8_x(body, svld1_u8(body, src + i - n), 1);
+                svint8_t _dst = svreinterpret_s8(svsub_u8_x(body, _src0, half));
+                svst1_s8(body, dst + i, _dst);
+                AddAbsSum(_dst, body, ones, zero, _sum);
+            }
+            if (i < size)
+            {
+                svbool_t tail = svwhilelt_b8(i, size);
+                svuint8_t _src0 = svld1_u8(tail, src + i);
+                svuint8_t half = svlsr_n_u8_x(tail, svld1_u8(tail, src + i - n), 1);
+                svint8_t _dst = svreinterpret_s8(svsub_u8_x(tail, _src0, half));
+                svst1_s8(tail, dst + i, _dst);
+                AddAbsSum(_dst, tail, ones, zero, _sum);
+            }
+            return sum + svaddv_u32(svptrue_b32(), _sum);
+        }
+
+        uint32_t EncodeLine6(const uint8_t* src, size_t stride, size_t n, size_t size, int8_t* dst)
+        {
+            const size_t A = svcntb();
+            const size_t sizeA = AlignLo(size - n, A) + n;
+            const svbool_t body = svptrue_b8();
+            const svuint8_t ones = svdup_n_u8(1);
+            const svuint8_t zero = svdup_n_u8(0);
+            uint32_t sum = 0;
+            size_t i = 0;
+            for (; i < n; ++i)
+            {
+                dst[i] = src[i];
+                sum += ::abs(dst[i]);
+            }
+            svuint32_t _sum = svdup_n_u32(0);
+            for (; i < sizeA; i += A)
+            {
+                svint8_t _dst = svsub_s8_x(body, svreinterpret_s8(svld1_u8(body, src + i)), svreinterpret_s8(svld1_u8(body, src + i - n)));
+                svst1_s8(body, dst + i, _dst);
+                AddAbsSum(_dst, body, ones, zero, _sum);
+            }
+            if (i < size)
+            {
+                svbool_t tail = svwhilelt_b8(i, size);
+                svint8_t _dst = svsub_s8_x(tail, svreinterpret_s8(svld1_u8(tail, src + i)), svreinterpret_s8(svld1_u8(tail, src + i - n)));
+                svst1_s8(tail, dst + i, _dst);
+                AddAbsSum(_dst, tail, ones, zero, _sum);
+            }
+            return sum + svaddv_u32(svptrue_b32(), _sum);
+        }
+
+        ImagePngSaver::ImagePngSaver(const ImageSaverParam& param)
+            : Neon::ImagePngSaver(param)
+        {
+            if (_param.format == SimdPixelFormatBgr24)
+                _convert = Sve2::BgrToRgb;
+            else if (_param.format == SimdPixelFormatBgra32)
+                _convert = Sve2::BgraToRgba;
+            _encode[0] = Sve2::EncodeLine0;
+            _encode[1] = Sve2::EncodeLine1;
+            _encode[2] = Sve2::EncodeLine2;
+            _encode[3] = Sve2::EncodeLine3;
+            _encode[4] = Sve2::EncodeLine4;
+            _encode[5] = Sve2::EncodeLine5;
+            _encode[6] = Sve2::EncodeLine6;
+            _compress = Sve2::ZlibCompress;
+        }
+    }
+#endif
+}
diff --git a/src/Test/TestImageIO.cpp b/src/Test/TestImageIO.cpp
index bcbdebe1de..124218f1db 100644
--- a/src/Test/TestImageIO.cpp
+++ b/src/Test/TestImageIO.cpp
@@ -256,7 +256,20 @@ namespace Test
 
 #ifdef SIMD_SVE2_ENABLE
         if (Simd::Sve2::Enable && TestSve2(options))
+        {
+            const size_t A = svcntb();
             result = result && ImageSaveToMemoryAutoTest(FUNC_SM(Simd::Sve2::ImageSaveToMemory), FUNC_SM(SimdImageSaveToMemory));
+            result = result && ImageSaveToMemoryAutoTest(3, 4, View::Gray8, SimdImageFilePng, 65,
+                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
+            result = result && ImageSaveToMemoryAutoTest(A + 1, 5, View::Bgr24, SimdImageFilePng, 65,
+                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
+            result = result && ImageSaveToMemoryAutoTest(A + 3, 7, View::Bgra32, SimdImageFilePng, 65,
+                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
+            result = result && ImageSaveToMemoryAutoTest(A + 2, 6, View::Rgb24, SimdImageFilePng, 65,
+                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
+            result = result && ImageSaveToMemoryAutoTest(A + 5, 8, View::Rgba32, SimdImageFilePng, 65,
+                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
+        }
 #endif
 
 #ifdef SIMD_NEON_ENABLE

From 7d1f05b4b214577bd7e99399544fdd1e756a6733 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Mon, 24 Aug 2026 15:41:55 +0000
Subject: [PATCH 2/2] Keep ImageSaveToMemory SVE2 tests on the standard sizes.

Remove extra tiny PNG cases so Base/SVE2 performance rows are not
mixed with 3x4 and other unaligned micro-benchmarks.

Co-authored-by: igor.ermolaev <igor.ermolaev@altezza.org>
---
 src/Test/TestImageIO.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/src/Test/TestImageIO.cpp b/src/Test/TestImageIO.cpp
index 124218f1db..bcbdebe1de 100644
--- a/src/Test/TestImageIO.cpp
+++ b/src/Test/TestImageIO.cpp
@@ -256,20 +256,7 @@ namespace Test
 
 #ifdef SIMD_SVE2_ENABLE
         if (Simd::Sve2::Enable && TestSve2(options))
-        {
-            const size_t A = svcntb();
             result = result && ImageSaveToMemoryAutoTest(FUNC_SM(Simd::Sve2::ImageSaveToMemory), FUNC_SM(SimdImageSaveToMemory));
-            result = result && ImageSaveToMemoryAutoTest(3, 4, View::Gray8, SimdImageFilePng, 65,
-                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
-            result = result && ImageSaveToMemoryAutoTest(A + 1, 5, View::Bgr24, SimdImageFilePng, 65,
-                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
-            result = result && ImageSaveToMemoryAutoTest(A + 3, 7, View::Bgra32, SimdImageFilePng, 65,
-                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
-            result = result && ImageSaveToMemoryAutoTest(A + 2, 6, View::Rgb24, SimdImageFilePng, 65,
-                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
-            result = result && ImageSaveToMemoryAutoTest(A + 5, 8, View::Rgba32, SimdImageFilePng, 65,
-                FUNC_SM(Simd::Base::ImageSaveToMemory), FUNC_SM(Simd::Sve2::ImageSaveToMemory));
-        }
 #endif
 
 #ifdef SIMD_NEON_ENABLE