Make compression level 0-100

CMakeLists.txt

@@ -1,6 +1,10 @@
 cmake_minimum_required(VERSION 3.14)
 
-project(libXISF VERSION 0.2.0 LANGUAGES CXX C)
+project(libXISF VERSION 0.2.12 LANGUAGES CXX C
+    HOMEPAGE_URL https://gitea.nouspiro.space/nou/libXISF
+    DESCRIPTION "LibXISF is C++ library that can read and write XISF files produced by PixInsight.")
+
+include(CMakeDependentOption)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_CXX_STANDARD 17)
@@ -9,15 +13,31 @@ set(CMAKE_C_VISIBILITY_PRESET hidden)
 set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 
 option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
-option(USE_BUNDLED_LIBS "Use bundled LZ4 PugiXML and Zlib" ON)
+option(USE_BUNDLED_LIBS "Use bundled LZ4 PugiXML and Zlib. You can still exclude some" ON)
+cmake_dependent_option(USE_BUNDLED_LZ4 "Use bundled LZ4" ON "USE_BUNDLED_LIBS" OFF)
+cmake_dependent_option(USE_BUNDLED_PUGIXML "Use bundled PugiXML" ON "USE_BUNDLED_LIBS" OFF)
+cmake_dependent_option(USE_BUNDLED_ZLIB "Use bundled Zlib" ON "USE_BUNDLED_LIBS" OFF)
 
-if(USE_BUNDLED_LIBS)
+find_package(PkgConfig)
-set(THIRD_PARTY_SRC
+
+if(USE_BUNDLED_LZ4)
+    list(APPEND THIRD_PARTY_SRC
         lz4/lz4.c
         lz4/lz4.h
         lz4/lz4hc.c
-    lz4/lz4hc.h
+        lz4/lz4hc.h)
-    pugixml/pugixml.cpp
+    list(APPEND THIRD_PARTY_INCLUDE lz4)
+else(USE_BUNDLED_LZ4)
+    pkg_check_modules(LZ4 liblz4 IMPORTED_TARGET REQUIRED)
+endif(USE_BUNDLED_LZ4)
+if(USE_BUNDLED_PUGIXML)
+    list(APPEND THIRD_PARTY_SRC pugixml/pugixml.cpp)
+    list(APPEND THIRD_PARTY_INCLUDE pugixml)
+else(USE_BUNDLED_PUGIXML)
+    pkg_check_modules(PUGIXML pugixml IMPORTED_TARGET REQUIRED)
+endif(USE_BUNDLED_PUGIXML)
+if(USE_BUNDLED_ZLIB)
+    list(APPEND THIRD_PARTY_SRC
         zlib/adler32.c
         zlib/compress.c
         zlib/crc32.c
@@ -36,31 +56,50 @@ set(THIRD_PARTY_SRC
     set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/zlib.pc)
     configure_file(${CMAKE_CURRENT_SOURCE_DIR}/zlib/zlib.pc.cmakein ${ZLIB_PC} @ONLY)
     configure_file(${CMAKE_CURRENT_SOURCE_DIR}/zlib/zconf.h.cmakein ${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY)
-else(USE_BUNDLED_LIBS)
+    list(APPEND THIRD_PARTY_INCLUDE zlib)
-    find_package(PkgConfig REQUIRED)
+else(USE_BUNDLED_ZLIB)
-    pkg_check_modules(LZ4 liblz4 IMPORTED_TARGET REQUIRED)
-    pkg_check_modules(PUGIXML pugixml IMPORTED_TARGET REQUIRED)
     pkg_check_modules(ZLIB zlib IMPORTED_TARGET REQUIRED)
-endif(USE_BUNDLED_LIBS)
+endif(USE_BUNDLED_ZLIB)
 
 add_library(XISF
   bytearray.cpp
   libXISF_global.h
   libxisf.cpp
   libxisf.h
+  streambuffer.cpp
+  streambuffer.h
   utils.cpp
   variant.cpp
   ${THIRD_PARTY_SRC}
 )
 
 if(USE_BUNDLED_LIBS)
-    target_include_directories(XISF PRIVATE lz4 pugixml zlib)
+    target_include_directories(XISF PRIVATE ${THIRD_PARTY_INCLUDE})
+    if(NOT USE_BUNDLED_LZ4)
+        target_link_libraries(XISF PUBLIC PkgConfig::LZ4)
+        list(APPEND PC_LIBS_REQUIRE lz4)
+    endif(NOT USE_BUNDLED_LZ4)
+    if(NOT USE_BUNDLED_PUGIXML)
+        target_link_libraries(XISF PUBLIC PkgConfig::PUGIXML)
+        list(APPEND PC_LIBS_REQUIRE pugixml)
+    endif(NOT USE_BUNDLED_PUGIXML)
+    if(NOT USE_BUNDLED_ZLIB)
+        target_link_libraries(XISF PUBLIC PkgConfig::ZLIB)
+        list(APPEND PC_LIBS_REQUIRE zlib)
+    endif(NOT USE_BUNDLED_ZLIB)
 else(USE_BUNDLED_LIBS)
     target_link_libraries(XISF PUBLIC PkgConfig::LZ4 PkgConfig::PUGIXML PkgConfig::ZLIB)
+    list(APPEND PC_LIBS_REQUIRE lz4 pugixml zlib)
 endif(USE_BUNDLED_LIBS)
 
 set_target_properties(XISF PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR})
 
+pkg_check_modules(ZSTD libzstd IMPORTED_TARGET)
+if(ZSTD_FOUND)
+    target_compile_definitions(XISF PRIVATE HAVE_ZSTD)
+    target_link_libraries(XISF PUBLIC PkgConfig::ZSTD)
+endif(ZSTD_FOUND)
+
 if(BUILD_SHARED_LIBS)
     target_compile_definitions(XISF PRIVATE LIBXISF_LIBRARY)
 else(BUILD_SHARED_LIBS)
@@ -72,8 +111,17 @@ set(XISF_PUBLIC_HEADERS libxisf.h libXISF_global.h)
 include(GNUInstallDirs)
 
 install(FILES ${XISF_PUBLIC_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libxisf.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 install(TARGETS XISF LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
+list(JOIN PC_LIBS_REQUIRE ", " PC_REQUIRE_STR2)
+if(NOT PC_REQUIRE_STR2 STREQUAL "")
+    string(REPLACE "lz4" "liblz4" PC_REQUIRE_STR ${PC_REQUIRE_STR2})
+endif()
+list(TRANSFORM PC_LIBS_REQUIRE PREPEND "-l")
+list(JOIN PC_LIBS_REQUIRE " " PC_LIBS_STR)
+configure_file(libxisf.pc.in libxisf.pc @ONLY)
+
 #testing
 
 enable_testing()

README.md

@@ -3,4 +3,15 @@ LibXISF
 
 LibXISF is C++ library that can read and write XISF files produced by [PixInsight](https://pixinsight.com/).
 It implement [XISF 1.0 specification](https://pixinsight.com/doc/docs/XISF-1.0-spec/XISF-1.0-spec.html).
-It is licensed under GPLv3. To compile you will need C++17 compiler.
+It is licensed under GPLv3 or later. To compile you will need C++17 compiler.
+
+To compile simply run these commands
+```
+cmake -B build -S .
+cmake --build build --parallel
+cmake --install build
+```
+
+By default it use bundled libraries. If you wish to use external libraries you will may add
+ `-DUSE_BUNDLED_LIBS=Off` to first command. Then you will need *lz4 pkg-config pugixml zlib* installed.
+You may also specify `-DBUILD_SHARED_LIBS=Off` if you want build static lib.

bytearray.cpp

@@ -1,3 +1,21 @@
+/************************************************************************
+ * LibXISF - library to load and save XISF files                        *
+ * Copyright (C) 2023 Dušan Poizl                                       *
+ *                                                                      *
+ * This program is free software: you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation, either version 3 of the License, or    *
+ * (at your option) any later version.                                  *
+ *                                                                      *
+ * This program is distributed in the hope that it will be useful,      *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
+ * GNU General Public License for more details.                         *
+ *                                                                      *
+ * You should have received a copy of the GNU General Public License    *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.*
+ ************************************************************************/
+
 #include "libxisf.h"
 
 namespace LibXISF

debian/changelog

@@ -1,29 +0,0 @@
-libxisf (0.2.0-ubuntu1) focal; urgency=medium
-
-  * Rewrite to remove Qt as dependency
-
- -- Dušan Poizl <nou@nouspiro.space>  Fri, 10 Mar 2023 22:10:01 +0100
-
-libxisf (0.1.3-ubuntu1) focal; urgency=medium
-
-  * Write missing pixelStorage attribute
-
- -- Dušan Poizl <nou@nouspiro.space>  Fri, 17 Feb 2023 16:57:30 +0100
-
-libxisf (0.1.2-ubuntu1) focal; urgency=medium
-
-  * Add qtbase5-dev as dependency to libxisf-dev
-
- -- Dušan Poizl <nou@nouspiro.space>  Thu, 09 Feb 2023 21:28:45 +0100
-
-libxisf (0.1.1-ubuntu1) focal; urgency=medium
-
-  * Fixed packaging
-
- -- Dušan Poizl <nou@nouspiro.space>  Wed, 08 Feb 2023 18:57:50 +0100
-
-libxisf (0.1.0-ubuntu1) focal; urgency=low
-
-  * Initial release.
-
- -- Dušan Poizl <nou@nouspiro.space>  Tue, 07 Feb 2023 10:47:08 +0100

debian/compat

@@ -1 +0,0 @@
-10

debian/control

@@ -1,25 +0,0 @@
-Source: libxisf
-Priority: optional
-Maintainer: Dušan Poizl <nou@nouspiro.space>
-Build-Depends: debhelper (>= 9),
-               cdbs,
-               cmake,
-Standards-Version: 4.5.0
-Section: libs
-Homepage: https://gitea.nouspiro.space/nou/libXISF
-Vcs-Git: https://gitea.nouspiro.space/nou/libXISF.git
-
-Package: libxisf-dev
-Section: libdevel
-Architecture: any
-Multi-Arch: same
-Depends: libxisf (= ${binary:Version}), ${misc:Depends}, qtbase5-dev
-Description: Library to load and save XISF images
- Native format of PixInsight astroprocessing suite
-
-Package: libxisf
-Architecture: any
-Multi-Arch: same
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: Library to load and save XISF images
- Native format of PixInsight astroprocessing suite

debian/copyright

@@ -1,52 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: libxisf
-Source: https://gitea.nouspiro.space/nou/libXISF
-
-Files: * debian/*
-Copyright: (c) 2023 <Dušan Poizl nou@nouspiro.space>
-License: GPL-3+
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
- .
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- .
- You should have received a copy of the GNU General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>.
- .
- On Debian systems, the complete texts of the GNU General Public Licenses
- version 2 and 3 can be found in '/usr/share/common-licenses/GPL-2' and
- '/usr/share/common-licenses/GPL-3'.
-
-Files: lz4/*
-Copyright: (c) 2011-2020, Yann Collet
-License: BSD-2-clause
- LZ4 Library
- Copyright (c) 2011-2020, Yann Collet
- All rights reserved.
- .
- Redistribution and use in source and binary forms, with or without modification,
- are permitted provided that the following conditions are met:
- .
- * Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
- .
- * Redistributions in binary form must reproduce the above copyright notice, this
- list of conditions and the following disclaimer in the documentation and/or
- other materials provided with the distribution.
- .
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-

debian/libxisf-dev.install

@@ -1,2 +0,0 @@
-usr/include
-usr/lib/*/*.so

debian/libxisf.install

@@ -1 +0,0 @@
-usr/lib/*/*.so.*

debian/rules

@@ -1,10 +0,0 @@
-#!/usr/bin/make -f
-
-#!/usr/bin/make -f
-
-include /usr/share/cdbs/1/rules/debhelper.mk
-include /usr/share/cdbs/1/class/cmake.mk
-
-export CFLAGS := $(shell dpkg-buildflags --get CFLAGS)
-export CXXFLAGS := $(shell dpkg-buildflags --get CXXFLAGS)
-export LDFLAGS := $(shell dpkg-buildflags --get LDFLAGS)

debian/source/format

@@ -1 +0,0 @@
-3.0 (quilt)

libxisf.cpp

@@ -23,10 +23,15 @@
 #include <iostream>
 #include <sstream>
 #include <cstdlib>
+#include <cmath>
 #include <lz4.h>
 #include <lz4hc.h>
 #include <pugixml.hpp>
 #include <zlib.h>
+#ifdef HAVE_ZSTD
+#include <zstd.h>
+#endif
+#include "streambuffer.h"
 
 namespace LibXISF
 {
@@ -45,6 +50,7 @@ static std::unordered_map<Image::ColorSpace, String> colorSpaceToString;
 static DataBlock::CompressionCodec compressionCodecOverride = DataBlock::None;
 static bool byteShuffleOverride = false;
 static int compressionLevelOverride = -1;
+const size_t GiB = 1073741824;
 
 static const std::unordered_map<String, std::pair<String, Variant::Type>> fitsNameToPropertyIdTypeConvert = {
     {"OBSERVER", {"Observer:Name", Variant::Type::String}},
@@ -82,12 +88,12 @@ static void byteShuffle(ByteArray &data, int itemSize)
     {
         ByteArray &input = data;
         ByteArray output(input.size());
-        int num = input.size() / itemSize;
+        size_t num = input.size() / itemSize;
         char *s = output.data();
         for(int i=0; i<itemSize; i++)
         {
             const char *u = input.constData() + i;
-            for(int o=0; o<num; o++, s++, u += itemSize)
+            for(size_t o=0; o<num; o++, s++, u += itemSize)
                 *s = *u;
         }
         memcpy(s, input.constData() + num * itemSize, input.size() % itemSize);
@@ -101,12 +107,12 @@ static void byteUnshuffle(ByteArray &data, int itemSize)
     {
         ByteArray &input = data;
         ByteArray output(input.size());
-        int num = input.size() / itemSize;
+        size_t num = input.size() / itemSize;
         const char *s = input.constData();
         for(int i=0; i<itemSize; i++)
         {
             char *u = output.data() + i;
-            for(int o=0; o<num; o++, s++, u += itemSize)
+            for(size_t o=0; o<num; o++, s++, u += itemSize)
                 *u = *s;
         }
         memcpy(output.data() + num * itemSize, s, input.size() % itemSize);
@@ -123,6 +129,9 @@ void DataBlock::decompress(const ByteArray &input, const String &encoding)
     else if(encoding == "base16")
         tmp.decodeHex();
 
+    if(subblocks.size() == 0)
+        subblocks.push_back({tmp.size(), uncompressedSize});
+
     switch(codec)
     {
     case None:
@@ -131,17 +140,54 @@ void DataBlock::decompress(const ByteArray &input, const String &encoding)
     case Zlib:
     {
         data.resize(uncompressedSize);
-        uLongf size = uncompressedSize;
+        const char *srcPtr = tmp.constData();
-        ::uncompress((Bytef*)data.data(), &size, (Bytef*)tmp.data(), tmp.size());
+        char *dstPtr = data.data();
+        for(auto &block : subblocks)
+        {
+            uLongf size = block.second;
+            ::uncompress((Bytef*)dstPtr, &size, (const Bytef*)srcPtr, block.first);
+            srcPtr += block.first;
+            dstPtr += block.second;
+        }
         break;
     }
     case LZ4:
     case LZ4HC:
+    {
         data.resize(uncompressedSize);
-        if(LZ4_decompress_safe(tmp.constData(), data.data(), tmp.size(), data.size()) < 0)
+        const char *srcPtr = tmp.constData();
+        char *dstPtr = data.data();
+        for(auto &block : subblocks)
+        {
+            if(LZ4_decompress_safe(srcPtr, dstPtr, block.first, block.second) < 0)
                 throw Error("LZ4 decompression failed");
+            srcPtr += block.first;
+            dstPtr += block.second;
+        }
         break;
     }
+    case ZSTD:
+#ifdef HAVE_ZSTD
+    {
+        data.resize(uncompressedSize);
+        const char *srcPtr = tmp.constData();
+        char *dstPtr = data.data();
+        for(auto &block : subblocks)
+        {
+            if(ZSTD_isError(ZSTD_decompress(dstPtr, block.second, srcPtr, block.first)))
+                throw Error("ZSTD decompression failed");
+            srcPtr += block.first;
+            dstPtr += block.second;
+        }
+
+    }
+#else
+        throw Error("ZSTD support not compiled");
+#endif
+        break;
+    }
+
+    subblocks.clear();
 
     byteUnshuffle(data, byteShuffling);
     attachmentPos = 0;
@@ -168,30 +214,77 @@ void DataBlock::compress(int sampleFormatSize)
         break;
     case Zlib:
     {
-        data.resize(compressBound(uncompressedSize));
+        int64_t size = tmp.size();
-        uLongf compressedSize = data.size();
+        int64_t compSize = 0;
-        if(::compress2((Bytef*)data.data(), &compressedSize, (Bytef*)tmp.data(), tmp.size(), compressLevel) != Z_OK)
+        int64_t inPtr = 0;
+        while(inPtr < size)
+        {
+            int64_t inSize = UINT32_MAX < size - inPtr ? UINT32_MAX : size - inPtr;
+            data.resize(compSize + compressBound(inSize));
+            uLongf outSize = data.size() - compSize;
+            if(::compress2((Bytef*)data.data() + compSize, &outSize, (const Bytef*)tmp.constData() + inPtr, inSize, compressLevel) != Z_OK)
                 throw Error("Zlib compression failed");
-        data.resize(compressedSize);
+
+            compSize += outSize;
+            inPtr += inSize;
+            subblocks.push_back({outSize, inSize});
+        }
+        data.resize(compSize);
         break;
     }
     case LZ4:
     case LZ4HC:
     {
-        int compSize = 0;
+        int64_t size = tmp.size();
-        data.resize(LZ4_compressBound(tmp.size()));
+        int64_t compSize = 0;
-        if(codec == LZ4)
+        int64_t inPtr = 0;
-            compSize = LZ4_compress_default(tmp.constData(), data.data(), tmp.size(), data.size());
+        while(inPtr < size)
-        else
+        {
-            compSize = LZ4_compress_HC(tmp.constData(), data.data(), tmp.size(), data.size(), compressLevel < 0 ? LZ4HC_CLEVEL_DEFAULT : compressLevel);
+            int64_t inSize = LZ4_MAX_INPUT_SIZE < size - inPtr ? LZ4_MAX_INPUT_SIZE : size - inPtr;
+            data.resize(compSize + LZ4_compressBound(inSize));
+            int outSize = 0;
 
-        if(compSize <= 0)
+            if(codec == LZ4)
+                outSize = LZ4_compress_default(tmp.constData() + inPtr, data.data() + compSize, inSize, data.size() - compSize);
+            else
+                outSize = LZ4_compress_HC(tmp.constData() + inPtr, data.data() + compSize, inSize, data.size() - compSize, compressLevel < 0 ? LZ4HC_CLEVEL_DEFAULT : compressLevel);
+
+            if(outSize <= 0)
                 throw Error("LZ4 compression failed");
 
+            compSize += outSize;
+            inPtr += inSize;
+            subblocks.push_back({outSize, inSize});
+        }
         data.resize(compSize);
         break;
     }
+    case ZSTD:
+    {
+#ifdef HAVE_ZSTD
+        size_t compSize = 0;
+        data.resize(ZSTD_compressBound(uncompressedSize));
+        compSize = ZSTD_compress(data.data(), data.size(), tmp.data(), tmp.size(), compressLevel < 0 ? ZSTD_CLEVEL_DEFAULT : compressLevel);
+        if(ZSTD_isError(compSize))
+            throw Error("ZSTD compression failed");
+
+        data.resize(compSize);
+#else
+        throw Error("ZSTD support not compiled");
+#endif
+        break;
     }
+    }
+}
+
+bool DataBlock::CompressionCodecSupported(CompressionCodec codec)
+{
+    (void)codec;
+#ifndef HAVE_ZSTD
+    if(codec == ZSTD)
+        return false;
+#endif
+    return true;
 }
 
 Property::Property(const String &_id, const char *_value) :
@@ -351,12 +444,26 @@ bool Image::addFITSKeywordAsProperty(const String &name, const String &value)
     {
         auto &c = fitsNameToPropertyIdTypeConvert.at(name);
         Property prop(c.first, variantFromString(c.second, value));
+
+        if(name == "APTDIA" || name == "FOCALLEN")
+            prop.value.value<LibXISF::Float32>() /= 1000.0f;
+
         updateProperty(prop);
         return true;
     }
     return false;
 }
 
+const ByteArray &Image::iccProfile() const
+{
+    return _iccProfile;
+}
+
+void Image::setIccProfile(const ByteArray &iccProfile)
+{
+    _iccProfile = iccProfile;
+}
+
 void *Image::imageData()
 {
     return _dataBlock.data.size() ? _dataBlock.data.data() : nullptr;
@@ -380,7 +487,38 @@ DataBlock::CompressionCodec Image::compression() const
 void Image::setCompression(DataBlock::CompressionCodec compression, int level)
 {
     _dataBlock.codec = compression;
-    _dataBlock.compressLevel = level;
+    _dataBlock.compressLevel = -1;
+
+    level = std::min(std::max(level, -1), 100);
+
+    auto percentToRange = [](int val, int min, int max)
+    {
+        double slope = (max - min) / 100.0;
+        return std::round(min + slope * val);
+    };
+
+    if(level >= 0)
+    {
+        switch(compression)
+        {
+        case DataBlock::CompressionCodec::Zlib:
+            _dataBlock.compressLevel = percentToRange(level, Z_BEST_SPEED, Z_BEST_COMPRESSION);
+            break;
+        case DataBlock::CompressionCodec::LZ4:
+        case DataBlock::CompressionCodec::LZ4HC:
+            _dataBlock.compressLevel = percentToRange(level, 1, LZ4HC_CLEVEL_MAX);
+            break;
+        case DataBlock::CompressionCodec::ZSTD:
+#ifdef HAVE_ZSTD
+            _dataBlock.compressLevel = percentToRange(level, ZSTD_minCLevel(), ZSTD_maxCLevel());
+#endif
+            break;
+        default:
+            //nothing
+            break;
+        }
+    }
+
 }
 
 bool Image::byteShuffling() const
@@ -520,6 +658,7 @@ public:
      *  @param readPixel when false it will read pixel data from file and imageData()
      *  will return nullptr */
     const Image& getImage(uint32_t n, bool readPixels = true);
+    const Image& getThumbnail();
 private:
     void readXISFHeader();
     void readSignature();
@@ -529,9 +668,12 @@ private:
     FITSKeyword parseFITSKeyword(const pugi::xml_node &node);
     ColorFilterArray parseCFA(const pugi::xml_node &node);
     Image parseImage(const pugi::xml_node &node);
+    void readAttachment(DataBlock &dataBlock);
 
     std::unique_ptr<std::istream> _io;
+    std::unique_ptr<StreamBuffer> _buffer;
     std::vector<Image> _images;
+    Image _thumbnail;
     std::vector<Property> _properties;
 };
 
@@ -546,8 +688,8 @@ void XISFReaderPrivate::open(const String &name)
 void XISFReaderPrivate::open(const ByteArray &data)
 {
     close();
-    std::string str((char*)data.data(), data.size());
+    _buffer = std::make_unique<StreamBuffer>(data);
-    _io = std::make_unique<std::istringstream>(str, std::ios_base::in | std::ios_base::binary);
+    _io = std::make_unique<std::istream>(_buffer.get());
     readSignature();
     readXISFHeader();
 }
@@ -563,6 +705,7 @@ void XISFReaderPrivate::open(std::istream *io)
 void XISFReaderPrivate::close()
 {
     _io.reset();
+    _buffer.reset();
     _images.clear();
     _properties.clear();
 }
@@ -579,13 +722,23 @@ const Image& XISFReaderPrivate::getImage(uint32_t n, bool readPixels)
 
     Image &img = _images[n];
     if(img._dataBlock.attachmentPos && readPixels)
+    {
+        readAttachment(img._dataBlock);
+    }
+    return img;
+}
+
+const Image &XISFReaderPrivate::getThumbnail()
+{
+    Image &img = _thumbnail;
+    if(_thumbnail._dataBlock.attachmentPos)
     {
         _io->seekg(img._dataBlock.attachmentPos);
         ByteArray data(img._dataBlock.attachmentSize);
         _io->read(data.data(), data.size());
         img._dataBlock.decompress(data);
     }
-    return img;
+    return _thumbnail;
 }
 
 void XISFReaderPrivate::readXISFHeader()
@@ -608,6 +761,9 @@ void XISFReaderPrivate::readXISFHeader()
 
         for(auto &property : root.children("Property"))
             _properties.push_back(parseProperty(property));
+
+        if(root.child("Thumbnail"))
+            _thumbnail = parseImage(root.child("Thumbnail"));
     }
     else throw Error("Unknown root XML element");
 }
@@ -634,10 +790,14 @@ void XISFReaderPrivate::parseCompression(const pugi::xml_node &node, DataBlock &
             dataBlock.codec = DataBlock::LZ4HC;
         else if(compression[0].find("lz4") == 0)
             dataBlock.codec = DataBlock::LZ4;
+#ifdef HAVE_ZSTD
+        else if(compression[0].find("zstd") == 0)
+            dataBlock.codec = DataBlock::ZSTD;
+#endif
         else
             throw Error("Unknown compression codec");
 
-        dataBlock.uncompressedSize = std::stoul(compression[1]);
+        dataBlock.uncompressedSize = std::stoull(compression[1]);
 
         if(compression[0].find("+sh") != std::string::npos)
         {
@@ -646,6 +806,18 @@ void XISFReaderPrivate::parseCompression(const pugi::xml_node &node, DataBlock &
             else
                 throw Error("Missing byte shuffling size");
         }
+
+        if(node.attribute("subblocks"))
+        {
+            std::vector<std::string> subblocks = splitString(node.attribute("subblocks").as_string(), ':');
+            for(auto &block : subblocks)
+            {
+                size_t pos = 0;
+                size_t comp = std::stoull(block, &pos);
+                size_t deco = std::stoull(block.substr(pos+1));
+                dataBlock.subblocks.push_back({comp, deco});
+            }
+        }
     }
 }
 
@@ -667,8 +839,8 @@ DataBlock XISFReaderPrivate::parseDataBlock(const pugi::xml_node &node)
     }
     else if(location.size() >= 3 && location[0] == "attachment")
     {
-        dataBlock.attachmentPos = std::stoul(location[1]);
+        dataBlock.attachmentPos = std::stoull(location[1]);
-        dataBlock.attachmentSize = std::stoul(location[2]);
+        dataBlock.attachmentSize = std::stoull(location[2]);
     }
     else
     {
@@ -703,17 +875,10 @@ Property XISFReaderPrivate::parseProperty(const pugi::xml_node &node)
     {
         DataBlock dataBlock = parseDataBlock(node);
         if(dataBlock.attachmentPos)
-        {
+            readAttachment(dataBlock);
-            data.resize(dataBlock.attachmentSize);
+
-            _io->seekg(dataBlock.attachmentPos);
-            _io->read(data.data(), dataBlock.attachmentSize);
-            dataBlock.decompress(data);
-        }
-        else
-        {
         data = dataBlock.data;
     }
-    }
 
     deserializeVariant(node, property.value, data);
 
@@ -751,9 +916,9 @@ Image XISFReaderPrivate::parseImage(const pugi::xml_node &node)
 
     std::vector<std::string> geometry = splitString(node.attribute("geometry").as_string(), ':');
     if(geometry.size() != 3)throw Error("We support only 2D images");
-    image._width = std::stoul(geometry[0]);
+    image._width = std::stoull(geometry[0]);
-    image._height = std::stoul(geometry[1]);
+    image._height = std::stoull(geometry[1]);
-    image._channelCount = std::stoul(geometry[2]);
+    image._channelCount = std::stoull(geometry[2]);
     if(!image._width || !image._height || !image._channelCount)throw Error("Invalid image geometry");
 
     std::vector<std::string> bounds = splitString(node.attribute("bounds").as_string(), ':');
@@ -781,12 +946,34 @@ Image XISFReaderPrivate::parseImage(const pugi::xml_node &node)
     if(node.child("ICCProfile"))
     {
         DataBlock icc = parseDataBlock(node.child("ICCProfile"));
+        if(icc.attachmentPos)
+            readAttachment(icc);
+
         image._iccProfile = icc.data;
     }
 
+    if(node.child("Thumbnail") && std::strcmp(node.name(), "Thumbnail"))
+        _thumbnail = parseImage(node.child("Thumbnail"));
+
     return image;
 }
 
+void XISFReaderPrivate::readAttachment(DataBlock &dataBlock)
+{
+    ByteArray data(dataBlock.attachmentSize);
+    _io->seekg(dataBlock.attachmentPos);
+    size_t size = dataBlock.attachmentSize;
+    char *ptr = data.data();
+    while(size > 0)
+    {
+        size_t s = std::min(size, GiB);
+        _io->read(ptr, s);
+        size -= s;
+        ptr += s;
+    }
+    dataBlock.decompress(data);
+}
+
 class  XISFWriterPrivate
 {
 public:
@@ -794,13 +981,14 @@ public:
     void save(ByteArray &data);
     void save(std::ostream &io);
     void writeImage(const Image &image);
+    static void writeFITSKeyword(pugi::xml_node &node, const FITSKeyword &keyword);
 private:
     void writeHeader();
     void writeImageElement(pugi::xml_node &node, const Image &image);
     void writeDataBlockAttributes(pugi::xml_node &image_node, const DataBlock &dataBlock);
     void writePropertyElement(pugi::xml_node &node, const Property &property);
-    void writeFITSKeyword(pugi::xml_node &node, const FITSKeyword &keyword);
     void writeMetadata(pugi::xml_node &node);
+    void updateImageAttachmentPos(pugi::xml_node &root, size_t offset);
     ByteArray _xisfHeader;
     ByteArray _attachmentsData;
     std::vector<Image> _images;
@@ -818,10 +1006,10 @@ void XISFWriterPrivate::save(const String &name)
 
 void XISFWriterPrivate::save(ByteArray &data)
 {
-    std::ostringstream oss;
+    StreamBuffer buffer;
+    std::ostream oss(&buffer);
     save(oss);
-    std::string str = oss.str();
+    data = buffer.byteArray();
-    data = ByteArray(str.data(), str.size());
 }
 
 void XISFWriterPrivate::save(std::ostream &io)
@@ -832,7 +1020,15 @@ void XISFWriterPrivate::save(std::ostream &io)
 
     for(auto &image : _images)
     {
-        io.write(image._dataBlock.data.constData(), image._dataBlock.data.size());
+        const char *ptr = image._dataBlock.data.constData();
+        size_t size = image._dataBlock.data.size();
+        while(size > 0)
+        {
+            size_t s = std::min(size, GiB);
+            io.write(ptr, s);
+            ptr += s;
+            size -= s;
+        }
     }
 }
 
@@ -863,25 +1059,26 @@ void XISFWriterPrivate::writeHeader()
 
     writeMetadata(root);
 
+    uint32_t size = 0;
+    std::string header;
+    while(true)
+    {
         std::stringstream xml;
         xml.write(signature, sizeof(signature));
         doc.save(xml, "", pugi::format_raw);
-
+        header = xml.str();
-    std::string header = xml.str();
+        if(size != header.size())
-    uint32_t size = header.size();
-
-    uint32_t offset = 0;
-    std::string replace = "attachment:2147483648";
-    for(auto &image : _images)
         {
-        std::string blockPos = std::string("attachment:") + std::to_string(size + offset);
+            size = header.size();
-        size_t pos = header.find(replace, 32);
+            updateImageAttachmentPos(root, size);
-        header.replace(pos, replace.size(), blockPos);
+        }
-        offset += image._dataBlock.data.size();
+        else
+        {
+            break;
+        }
     }
 
-    uint32_t headerSize = size - sizeof(signature);
+    uint32_t headerSize = header.size() - sizeof(signature);
-    header.resize(size, 0);
     header.replace(8, sizeof(uint32_t), (const char*)&headerSize, sizeof(uint32_t));
 
     _xisfHeader = ByteArray(header.c_str(), header.size());
@@ -912,7 +1109,7 @@ void XISFWriterPrivate::writeImageElement(pugi::xml_node &node, const Image &ima
 
     if(image._cfa.width && image._cfa.height)
     {
-        pugi::xml_node cfa_node = node.append_child("ColorFilterArray");
+        pugi::xml_node cfa_node = image_node.append_child("ColorFilterArray");
         cfa_node.append_attribute("pattern").set_value(image._cfa.pattern.c_str());
         cfa_node.append_attribute("width").set_value(image._cfa.width);
         cfa_node.append_attribute("height").set_value(image._cfa.height);
@@ -921,7 +1118,8 @@ void XISFWriterPrivate::writeImageElement(pugi::xml_node &node, const Image &ima
     if(image._iccProfile.size())
     {
         ByteArray base64 = image._iccProfile;
-        base64.decodeBase64();
+        base64.encodeBase64();
+        base64.append('\0');
         pugi::xml_node icc_node = image_node.append_child("ICCProfile");
         icc_node.append_attribute("location").set_value("inline:base64");
         icc_node.append_child(pugi::node_pcdata).set_value(base64.data());
@@ -940,7 +1138,10 @@ void XISFWriterPrivate::writeDataBlockAttributes(pugi::xml_node &image_node, con
     }
     else
     {
-        std::string attachment = "attachment:2147483648:" + std::to_string(dataBlock.data.size());
+        std::string attachment = "attachment:";
+        if(dataBlock.attachmentPos == 0) attachment += "99999";
+        else attachment += std::to_string(dataBlock.attachmentPos);
+        attachment += ":" + std::to_string(dataBlock.data.size());
         image_node.append_attribute("location").set_value(attachment.c_str());
     }
 
@@ -952,6 +1153,12 @@ void XISFWriterPrivate::writeDataBlockAttributes(pugi::xml_node &image_node, con
         codec = "lz4";
     else if(dataBlock.codec == DataBlock::LZ4HC)
         codec = "lz4hc";
+    else if(dataBlock.codec == DataBlock::ZSTD)
+#ifdef HAVE_ZSTD
+        codec = "zstd";
+#else
+        throw Error("ZSTD support not compiled");
+#endif
 
     if(dataBlock.byteShuffling > 1)
         codec += "+sh";
@@ -964,6 +1171,19 @@ void XISFWriterPrivate::writeDataBlockAttributes(pugi::xml_node &image_node, con
 
         image_node.append_attribute("compression").set_value(codec.c_str());
     }
+
+    if(!dataBlock.subblocks.empty())
+    {
+        std::string subblocks;
+        for(auto i = dataBlock.subblocks.begin(); i != dataBlock.subblocks.end(); i++)
+        {
+            if(i != dataBlock.subblocks.begin())
+                subblocks += ":";
+
+            subblocks += std::to_string(i->first) + "," + std::to_string(i->second);
+        }
+        image_node.append_attribute("subblocks").set_value(subblocks.c_str());
+    }
 }
 
 void XISFWriterPrivate::writePropertyElement(pugi::xml_node &node, const Property &property)
@@ -994,6 +1214,19 @@ void XISFWriterPrivate::writeMetadata(pugi::xml_node &node)
     writePropertyElement(metadata, Property("XISF:CreatorApplication", "LibXISF"));
 }
 
+void XISFWriterPrivate::updateImageAttachmentPos(pugi::xml_node &root, size_t offset)
+{
+    pugi::xpath_node_set imageNodes = root.select_nodes("//Image");
+    int i = 0;
+    for(auto &image : _images)
+    {
+        pugi::xml_node node = imageNodes[i++].node();
+        std::string location = "attachment:" + std::to_string(offset) + ":" + std::to_string(image._dataBlock.data.size());
+        offset += image._dataBlock.data.size();
+        node.attribute("location").set_value(location.c_str());
+    }
+}
+
 XISFReader::XISFReader()
 {
     p = new XISFReaderPrivate;
@@ -1034,6 +1267,11 @@ const Image &XISFReader::getImage(uint32_t n, bool readPixels)
     return p->getImage(n, readPixels);
 }
 
+const Image &XISFReader::getThumbnail()
+{
+    return p->getThumbnail();
+}
+
 XISFWriter::XISFWriter()
 {
     p = new XISFWriterPrivate;
@@ -1064,6 +1302,321 @@ void XISFWriter::writeImage(const Image &image)
     p->writeImage(image);
 }
 
+class XISFModifyPrivate
+{
+public:
+    void open(const String &name);
+    void open(const ByteArray &data);
+    /** Open image from istream. This method takes ownership of *io pointer */
+    void open(std::istream *io);
+    /** Close opended file release all data. */
+    void close();
+
+    void save(const String &name);
+    void save(ByteArray &data);
+    void save(std::ostream &io);
+
+    void addFITSKeyword(uint32_t image, const FITSKeyword &keyword);
+    void updateFITSKeyword(uint32_t image, const FITSKeyword &keyword, bool add);
+    void removeFITSKeyword(uint32_t image, const String &name);
+private:
+    void readXISFHeader();
+    void parseAttachmentPos(pugi::xml_node &root);
+    void updateAttachmentPos(pugi::xml_node &root, size_t offset);
+
+    std::unique_ptr<std::istream> _io;
+    std::unique_ptr<StreamBuffer> _buffer;
+
+    pugi::xml_document _doc;
+    pugi::xml_node _root;
+    std::map<int, std::pair<uint64_t, uint64_t>> _attachmentPos;// pair contain position and size
+    std::map<int, std::pair<uint64_t, uint64_t>> _attachmentPosNew;
+};
+
+
+void XISFModifyPrivate::open(const String &name)
+{
+    close();
+    _io = std::make_unique<std::ifstream>(name.c_str(), std::ios_base::in | std::ios_base::binary);
+    readXISFHeader();
+}
+
+void XISFModifyPrivate::open(const ByteArray &data)
+{
+    close();
+    _buffer = std::make_unique<StreamBuffer>(data);
+    _io = std::make_unique<std::istream>(_buffer.get());
+    readXISFHeader();
+}
+
+void XISFModifyPrivate::open(std::istream *io)
+{
+    close();
+    _io.reset(io);
+    readXISFHeader();
+}
+
+void XISFModifyPrivate::close()
+{
+    _io.reset();
+    _buffer.reset();
+    _root = pugi::xml_node();
+    _doc.reset();
+}
+
+void XISFModifyPrivate::save(const String &name)
+{
+    std::ofstream fw(name.c_str(), std::ios_base::out | std::ios_base::binary);
+
+    if(fw.fail())
+        throw Error("Failed to open file");
+
+    save(fw);
+}
+
+void XISFModifyPrivate::save(ByteArray &data)
+{
+    StreamBuffer buffer;
+    std::ostream oss(&buffer);
+    save(oss);
+    data = buffer.byteArray();
+}
+
+void XISFModifyPrivate::save(std::ostream &io)
+{
+    if(!_io || !_root)
+        throw Error("No input file opened");
+
+    const char signature[16] = {'X', 'I', 'S', 'F', '0', '1', '0', '0', 0, 0, 0, 0, 0, 0, 0, 0};
+
+    pugi::xml_document doc;
+    doc.append_child(pugi::node_comment).set_value("\nExtensible Image Serialization Format - XISF version 1.0\nCreated with libXISF - https://nouspiro.space\n");
+    pugi::xml_node root_copy = doc.append_copy(_root);
+
+    uint32_t size = 0;
+    std::string header;
+    while(true)
+    {
+        std::stringstream xml;
+        xml.write(signature, sizeof(signature));
+        doc.save(xml, "", pugi::format_raw);
+        header = xml.str();
+        if(size != header.size())
+        {
+            size = header.size();
+            updateAttachmentPos(root_copy, size);
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    uint32_t headerSize = header.size() - sizeof(signature);
+    header.replace(8, sizeof(uint32_t), (const char*)&headerSize, sizeof(uint32_t));
+
+    io.write(header.c_str(), header.size());
+    const uint64_t BLOCK_SIZE = 1024*1024*4;
+    std::vector<char> data(BLOCK_SIZE);
+    for(auto &pos : _attachmentPos)
+    {
+        uint64_t oldPos = pos.second.first;
+        uint64_t size = pos.second.second;
+
+        _io->seekg(oldPos);
+        while(size)
+        {
+            _io->read(&data[0], std::min(size, BLOCK_SIZE));
+            io.write(&data[0], std::min(size, BLOCK_SIZE));
+            size -= std::min(size, BLOCK_SIZE);
+        }
+    }
+}
+
+void XISFModifyPrivate::addFITSKeyword(uint32_t image, const FITSKeyword &keyword)
+{
+    if(!_root)
+        throw Error("No input file opened");
+
+    pugi::xpath_node_set images = _root.select_nodes("//Image");
+
+    if(image >= images.size())
+        throw Error("Out of bounds");
+
+    pugi::xml_node imageNode = images[image].node();
+    XISFWriterPrivate::writeFITSKeyword(imageNode, keyword);
+}
+
+void XISFModifyPrivate::updateFITSKeyword(uint32_t image, const FITSKeyword &keyword, bool add)
+{
+    if(!_root)
+        throw Error("No input file opened");
+
+    pugi::xpath_node_set images = _root.select_nodes("//Image");
+
+    if(image >= images.size())
+        throw Error("Out of bounds");
+
+    pugi::xpath_variable_set variables;
+    variables.set("name", keyword.name.c_str());
+    pugi::xml_node imageNode = images[image].node();
+    pugi::xml_node keywordNode = imageNode.select_node("FITSKeyword[@name=string($name)]", &variables).node();
+
+    if(keywordNode)
+    {
+        if(keywordNode.attribute("value"))
+            keywordNode.attribute("value").set_value(keyword.value.c_str());
+        else
+            keywordNode.append_attribute("value").set_value(keyword.value.c_str());
+
+        if(keywordNode.attribute("comment"))
+            keywordNode.attribute("comment").set_value(keyword.comment.c_str());
+        else
+            keywordNode.append_attribute("comment").set_value(keyword.comment.c_str());
+    }
+    else if(add)
+    {
+        XISFWriterPrivate::writeFITSKeyword(imageNode, keyword);
+    }
+}
+
+void XISFModifyPrivate::removeFITSKeyword(uint32_t image, const String &name)
+{
+    if(!_root)
+        throw Error("No input file opened");
+
+    pugi::xpath_node_set images = _root.select_nodes("//Image");
+
+    if(image >= images.size())
+        throw Error("Out of bounds");
+
+    pugi::xpath_variable_set variables;
+    variables.set("name", name.c_str());
+    pugi::xml_node imageNode = images[image].node();
+    pugi::xml_node keywordNode = imageNode.select_node("FITSKeyword[@name=string($name)]", &variables).node();
+
+    if(keywordNode)
+        imageNode.remove_child(keywordNode);
+}
+
+void XISFModifyPrivate::readXISFHeader()
+{
+    char signature[8];
+    _io->read(signature, sizeof(signature));
+    if(_io->fail())
+        throw Error("Failed to read from file");
+
+    if(memcmp(signature, "XISF0100", sizeof(signature)) != 0)
+        throw Error("Not valid XISF 1.0 file");
+
+    uint32_t headerLen[2] = {0};
+    _io->read((char*)&headerLen, sizeof(headerLen));
+
+    ByteArray xisfHeader(headerLen[0]);
+    _io->read(xisfHeader.data(), headerLen[0]);
+
+    _doc.load_buffer(xisfHeader.data(), xisfHeader.size());
+
+    _root = _doc.child("xisf");
+
+    parseAttachmentPos(_root);
+
+    if(!_root || _root.attribute("version").as_string() != std::string("1.0"))
+        throw Error("Unknown root XML element");
+}
+
+void XISFModifyPrivate::parseAttachmentPos(pugi::xml_node &root)
+{
+    pugi::xpath_node_set locationAttributes = root.select_nodes("//@location");
+    int i = 0;
+    for(auto &attr : locationAttributes)
+    {
+        std::string locationStr = attr.attribute().as_string();
+        std::vector<std::string> location = splitString(locationStr, ':');
+        if(location.size() >= 3 && location[0] == "attachment")
+        {
+            uint64_t attachmentPos = std::stoull(location[1]);
+            uint64_t attachmentSize = std::stoull(location[2]);
+            _attachmentPos[i] = {attachmentPos, attachmentSize};
+        }
+        i++;
+    }
+}
+
+void XISFModifyPrivate::updateAttachmentPos(pugi::xml_node &root, size_t offset)
+{
+    pugi::xpath_node_set locationAttributes = root.select_nodes("//@location");
+    for(auto &pos : _attachmentPos)
+    {
+        pugi::xml_attribute attr = locationAttributes[pos.first].attribute();
+        uint64_t attachmentSize = pos.second.second;
+        std::string locationStr = "attachment:" + std::to_string(offset) + ":" + std::to_string(attachmentSize);
+        _attachmentPosNew[pos.first] = pos.second;
+        offset += attachmentSize;
+        attr.set_value(locationStr.c_str());
+    }
+}
+
+XISFModify::XISFModify()
+{
+    p = new XISFModifyPrivate();
+}
+
+XISFModify::~XISFModify()
+{
+    delete p;
+}
+
+void XISFModify::open(const String &name)
+{
+    p->open(name);
+}
+
+void XISFModify::open(const ByteArray &data)
+{
+    p->open(data);
+}
+
+void XISFModify::open(std::istream *io)
+{
+    p->open(io);
+}
+
+void XISFModify::close()
+{
+    p->close();
+}
+
+void XISFModify::save(const String &name)
+{
+    p->save(name);
+}
+
+void XISFModify::save(ByteArray &data)
+{
+    p->save(data);
+}
+
+void XISFModify::save(std::ostream &io)
+{
+    p->save(io);
+}
+
+void XISFModify::addFITSKeyword(uint32_t image, const FITSKeyword &keyword)
+{
+    p->addFITSKeyword(image, keyword);
+}
+
+void XISFModify::updateFITSKeyword(uint32_t image, const FITSKeyword &keyword, bool add)
+{
+    p->updateFITSKeyword(image, keyword, add);
+}
+
+void XISFModify::removeFITSKeyword(uint32_t image, const String &name)
+{
+    p->removeFITSKeyword(image, name);
+}
+
 #define STRING_ENUM(map, map2, c, e) { map.insert({#e, c::e}); map2.insert({c::e, #e}); }
 
 struct Init
@@ -1108,6 +1661,10 @@ struct Init
                 compressionCodecOverride = DataBlock::LZ4HC;
             else if(compression.find("lz4") == 0)
                 compressionCodecOverride = DataBlock::LZ4;
+#ifdef HAVE_ZSTD
+            else if(compression.find("zstd") == 0)
+                compressionCodecOverride = DataBlock::ZSTD;
+#endif
 
             if(compression.find("+sh") != std::string::npos)
                 byteShuffleOverride = true;

libxisf.h

@@ -35,6 +35,7 @@ namespace LibXISF
 
 class XISFReaderPrivate;
 class XISFWriterPrivate;
+class XISFModifyPrivate;
 
 class LIBXISF_EXPORT ByteArray
 {
@@ -172,18 +173,22 @@ struct LIBXISF_EXPORT DataBlock
         None,
         Zlib,
         LZ4,
-        LZ4HC
+        LZ4HC,
+        ZSTD
     };
     bool embedded = false;
     uint32_t byteShuffling = 0;
     uint64_t attachmentPos = 0;
     uint64_t attachmentSize = 0;
     uint64_t uncompressedSize = 0;
+    std::vector<std::pair<uint64_t, uint64_t>> subblocks;
     CompressionCodec codec = None;
     int compressLevel = -1;
     ByteArray data;
     void decompress(const ByteArray &input, const std::string &encoding = "");
     void compress(int sampleFormatSize);
+    /// ZSTD compression can be disabled at compile time
+    static bool CompressionCodecSupported(CompressionCodec codec);
 };
 
 struct LIBXISF_EXPORT Property
@@ -301,6 +306,8 @@ public:
      *  For example OBSERVER => Observer:Name, SITELAT => Observation:Location:Latitude
     */
     bool addFITSKeywordAsProperty(const String &name, const String &value);
+    const ByteArray& iccProfile() const;
+    void setIccProfile(const ByteArray &iccProfile);
 
     void* imageData();
     const void* imageData() const;
@@ -310,6 +317,11 @@ public:
     const T* imageData() const { return static_cast<T*>(imageData()); }
     size_t imageDataSize() const;
     DataBlock::CompressionCodec compression() const;
+    /** Set compression type and level.
+     *  @param compression define which compression algorithm to use.
+     *  @param level number between 0 and 100. Zero means lowest compression and maximum speed. Hundred means maximum compression speed.
+     *  -1 means default compression level defined by compression library.
+     */
     void setCompression(DataBlock::CompressionCodec compression, int level = -1);
     bool byteShuffling() const;
     void setByteshuffling(bool enable);
@@ -364,9 +376,14 @@ public:
     int imagesCount() const;
     /** Return reference to Image
      *  @param n index of image
-     *  @param readPixel when false it will read pixel data from file and imageData()
+     *  @param readPixel when false it will not read pixel data from file and imageData()
-     *  will return nullptr */
+     *  will return nullptr. Other properties like width, height, format etc will be returned correctly */
     const Image& getImage(uint32_t n, bool readPixels = true);
+    /**
+     * @brief getThumbnail
+     * @return image thumbnail
+     */
+    const Image& getThumbnail();
 private:
     XISFReaderPrivate *p;
 };
@@ -394,6 +411,42 @@ public:
     const char* what() const noexcept { return _msg.c_str(); }
 };
 
+class LIBXISF_EXPORT XISFModify
+{
+public:
+    XISFModify();
+    virtual ~XISFModify();
+    void open(const String &name);
+    void open(const ByteArray &data);
+    void open(std::istream *io);
+    void close();
+    void save(const String &name);
+    void save(ByteArray &data);
+    void save(std::ostream &io);
+
+    /**
+     * @brief addFITSKeyword append new keyword to image
+     * @param image index of image to update
+     * @param keyword that will be added
+     */
+    void addFITSKeyword(uint32_t image, const FITSKeyword &keyword);
+    /**
+     * @brief updateFITSKeyword update keyword with same name
+     * @param image index of image to update
+     * @param keyword that will be updated
+     * @param add if true then it will add new keyword in case that it doesn't exists
+     */
+    void updateFITSKeyword(uint32_t image, const FITSKeyword &keyword, bool add);
+    /**
+     * @brief removeFITSKeyword remove keyword with name from image
+     * @param image index of image to update
+     * @param name of keyword that will be removed
+     */
+    void removeFITSKeyword(uint32_t image, const String &name);
+private:
+    XISFModifyPrivate *p;
+};
+
 template<typename T>
 constexpr Image::SampleFormat Image::sampleFormatEnum()
 {

libxisf.pc.in

@@ -0,0 +1,12 @@
+prefix="@CMAKE_INSTALL_PREFIX@"
+exec_prefix="${prefix}"
+libdir="${exec_prefix}/@CMAKE_INSTALL_LIBDIR@"
+includedir="${prefix}/@CMAKE_INSTALL_INCLUDEDIR@"
+
+Name: @PROJECT_NAME@
+Description: @CMAKE_PROJECT_DESCRIPTION@
+URL: @CMAKE_PROJECT_HOMEPAGE_URL@
+Version: @PROJECT_VERSION@
+Requires.private: @PC_REQUIRE_STR@
+Cflags: -I"${includedir}"
+Libs: -L"${libdir}" -lXISF

pugixml/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2006-2022 Arseny Kapoulkine
+
+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.

streambuffer.cpp

@@ -0,0 +1,162 @@
+/************************************************************************
+ * LibXISF - library to load and save XISF files                        *
+ * Copyright (C) 2024 Dušan Poizl                                       *
+ *                                                                      *
+ * This program is free software: you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation, either version 3 of the License, or    *
+ * (at your option) any later version.                                  *
+ *                                                                      *
+ * This program is distributed in the hope that it will be useful,      *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
+ * GNU General Public License for more details.                         *
+ *                                                                      *
+ * You should have received a copy of the GNU General Public License    *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.*
+ ************************************************************************/
+
+#include "streambuffer.h"
+
+namespace LibXISF
+{
+
+StreamBuffer::StreamBuffer()
+{
+    setg(nullptr, nullptr, nullptr);
+    setp(nullptr, nullptr);
+}
+
+StreamBuffer::StreamBuffer(const ByteArray &byteArray) :
+    _size(byteArray.size()),
+    _byteArray(byteArray)
+{
+    if(_byteArray.size())
+    {
+        char *ptr = _byteArray.data();
+        setg(ptr, ptr, ptr + _size);
+        setp(ptr, ptr + _size);
+    }
+    else
+    {
+        setg(nullptr, nullptr, nullptr);
+        setp(nullptr, nullptr);
+    }
+}
+
+ByteArray StreamBuffer::byteArray()
+{
+    return _byteArray;
+}
+
+StreamBuffer::pos_type StreamBuffer::seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode mode)
+{
+    pos_type ret = pos_type(off_type(-1));
+    off_type newoffi = off;
+    off_type newoffo = off;
+    if(dir == std::ios_base::cur)
+    {
+        newoffi += gptr() - eback();
+        newoffo += pptr() - pbase();
+    }
+    else if(dir == std::ios_base::end)
+        newoffo = newoffi = _byteArray.size() - off;
+
+    char *ptr = _byteArray.data();
+    if(mode & std::ios_base::in && newoffi >= 0 && newoffi <= _size)
+    {
+        setg(ptr, ptr + newoffi, ptr + _size);
+        ret = pos_type(newoffi);
+    }
+
+    if(mode & std::ios_base::out && newoffo >= 0 && newoffo <= _size)
+    {
+        setp(ptr, ptr + _size);
+        pbump(newoffo);
+        ret = pos_type(newoffo);
+    }
+
+    return ret;
+}
+
+StreamBuffer::pos_type StreamBuffer::seekpos(pos_type pos, std::ios_base::openmode mode)
+{
+    pos_type ret = pos_type(off_type(-1));
+    off_type off = pos;
+
+    if(off >= 0 && off <= (off_type)_byteArray.size())
+    {
+        char *ptr = _byteArray.data();
+        if(mode & std::ios_base::in)
+            setg(ptr, ptr + pos, ptr + _size);
+
+        if(mode & std::ios_base::out)
+        {
+            setp(ptr, ptr + _size);
+            pbump(pos);
+        }
+
+        ret = pos;
+    }
+    return ret;
+}
+
+std::streamsize StreamBuffer::xsgetn(char_type *s, std::streamsize n)
+{
+    std::streamsize ret = 0;
+    std::streamsize len = egptr() - gptr();
+    if(len > 0)
+    {
+        std::streamsize c = n < len ? n : len;
+        std::memcpy(s, gptr(), c);
+        gbump(c);
+        ret = c;
+    }
+    return ret;
+}
+
+StreamBuffer::int_type StreamBuffer::underflow()
+{
+    if(gptr() < egptr())
+        return traits_type::to_int_type(*gptr());
+    else
+        return traits_type::eof();
+}
+
+std::streamsize StreamBuffer::xsputn(const char_type *s, std::streamsize n)
+{
+    off_type len = epptr() - pptr();
+    if(len < n)
+    {
+        _size += n - len;
+        _byteArray.resize(_size);
+        update_ptrs();
+    }
+    std::memcpy(pptr(), s, n);
+    pbump(n);
+    return n;
+}
+
+StreamBuffer::int_type StreamBuffer::overflow(int_type c)
+{
+    if(traits_type::eq_int_type(traits_type::eof(), c))
+        return traits_type::eof();
+
+    _byteArray.append(c);
+    _size++;
+    pbump(1);
+    update_ptrs();
+    return c;
+}
+
+void StreamBuffer::update_ptrs()
+{
+    off_type ipos = gptr() - eback();
+    off_type opos = pptr() - pbase();
+    char *ptr = _byteArray.data();
+    setg(ptr, ptr + ipos, ptr + _size);
+    setp(ptr, ptr + _size);
+    pbump(opos);
+}
+
+}

streambuffer.h

@@ -0,0 +1,51 @@
+/************************************************************************
+ * LibXISF - library to load and save XISF files                        *
+ * Copyright (C) 2024 Dušan Poizl                                       *
+ *                                                                      *
+ * This program is free software: you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation, either version 3 of the License, or    *
+ * (at your option) any later version.                                  *
+ *                                                                      *
+ * This program is distributed in the hope that it will be useful,      *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
+ * GNU General Public License for more details.                         *
+ *                                                                      *
+ * You should have received a copy of the GNU General Public License    *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.*
+ ************************************************************************/
+
+#ifndef STREAMBUFFER_H
+#define STREAMBUFFER_H
+
+#include <streambuf>
+#include "libxisf.h"
+
+namespace LibXISF
+{
+
+class StreamBuffer : public std::streambuf
+{
+public:
+    StreamBuffer();
+    StreamBuffer(const ByteArray &byteArray);
+    ByteArray byteArray();
+protected:
+    pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out) override;
+    pos_type seekpos(pos_type pos, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out) override;
+
+    std::streamsize xsgetn(char_type *s, std::streamsize n) override;
+    int_type underflow() override;
+
+    std::streamsize xsputn(const char_type *s, std::streamsize n) override;
+    int_type overflow(int_type c = traits_type::eof()) override;
+private:
+    void update_ptrs();
+    off_type _size = 0;
+    ByteArray _byteArray;
+};
+
+}
+
+#endif // STREAMBUFFER_H

test/benchmark.cpp

@@ -78,6 +78,17 @@ void benchmarkType(float avg, float stdDev)
         std::cout << "LZ4HC compression   \tElapsed time: " << timer.elapsed() << " " << "ms\tSpeed: "
                   << size/1024.0/1.024/timer.elapsed() << "MiB/s\tRatio: " << baseSize/xisfImage.size() << std::endl;
     }
+    if(DataBlock::CompressionCodecSupported(DataBlock::ZSTD))
+    {
+        image.setCompression(DataBlock::ZSTD);
+        timer.start();
+        XISFWriter writer;
+        writer.writeImage(image);
+        ByteArray xisfImage;
+        writer.save(xisfImage);
+        std::cout << "ZSTD compression   \tElapsed time: " << timer.elapsed() << " " << "ms\tSpeed: "
+                  << size/1024.0/1.024/timer.elapsed() << "MiB/s\tRatio: " << baseSize/xisfImage.size() << std::endl;
+    }
     image.setByteshuffling(true);
     {
         image.setCompression(DataBlock::Zlib);
@@ -109,6 +120,17 @@ void benchmarkType(float avg, float stdDev)
         std::cout << "LZ4HC compression SH\tElapsed time: " << timer.elapsed() << " " << "ms\tSpeed: "
                   << size/1024.0/1.024/timer.elapsed() << "MiB/s\tRatio: " << baseSize/xisfImage.size() << std::endl;
     }
+    if(DataBlock::CompressionCodecSupported(DataBlock::ZSTD))
+    {
+        image.setCompression(DataBlock::ZSTD);
+        timer.start();
+        XISFWriter writer;
+        writer.writeImage(image);
+        ByteArray xisfImage;
+        writer.save(xisfImage);
+        std::cout << "ZSTD compression SH\tElapsed time: " << timer.elapsed() << " " << "ms\tSpeed: "
+                  << size/1024.0/1.024/timer.elapsed() << "MiB/s\tRatio: " << baseSize/xisfImage.size() << std::endl;
+    }
 }
 
 void benchmark()

test/main.cpp

@@ -54,7 +54,7 @@ int main(int argc, char **argv)
             m(0, 2) = 2;
             m(1, 0) = 10;
             image.addProperty(Property("UI16Matrix", m));
-            std::tm tm = {12, 22, 23, 1, 2, 2023, 0, 0, 0, 0, 0};
+            std::tm tm = {12, 22, 23, 1, 2, 2023, 0, 0, 0};
             image.addProperty(Property("TimeObs", tm));
             image.addFITSKeyword({"RA", "226.9751163116387", "Right ascension of the center of the image (deg)"});
             image.addFITSKeyword({"DEC", "62.02302376908295", "Declination of the center of the image (deg)"});
@@ -94,7 +94,14 @@ int main(int argc, char **argv)
             TEST(image.height() != 10, "Invalid height");
             TEST(image.colorSpace() != LibXISF::Image::Gray, "Invalid color space");
             TEST(image.pixelStorage() != LibXISF::Image::Planar, "Invalid pixel storage");
+            if(std::strstr(argv[1], "lz4"))
+            {
+                TEST(image.compression() != LibXISF::DataBlock::LZ4, "Invalid compression codec");
+            }
+            else
+            {
                 TEST(image.compression() != LibXISF::DataBlock::None, "Invalid compression codec");
+            }
             //TEST(!image.dataBlock.embedded, "Not embedded");
             TEST(image.imageDataSize() != 80*2, "Invalid data size");
         }

utils.cpp

@@ -52,7 +52,7 @@ void sha1(uint8_t *data, size_t len, uint8_t *hash)
     nlen += 64 - nlen % 64;
     tmp.resize(nlen, 0);
 
-    size_t ml = len * 8;
+    uint64_t ml = len * 8;
     tmp[nlen - 1] = ml & 0xff;
     tmp[nlen - 2] = ml >>  8 & 0xff;
     tmp[nlen - 3] = ml >> 16 & 0xff;

variant.cpp

@@ -21,8 +21,9 @@
 #include <map>
 #include <regex>
 #include <iomanip>
+#include <sstream>
 #include "libxisf.h"
-#include "pugixml/pugixml.hpp"
+#include <pugixml.hpp>
 
 namespace LibXISF
 {
@@ -107,8 +108,8 @@ static std::map<Variant::Type, const char*> idToType = {
     {Variant::Type::UI32Matrix,    "UI32Matrix"},
     {Variant::Type::I64Matrix,     "I64Matrix"},
     {Variant::Type::UI64Matrix,    "UI64Matrix"},
-    {Variant::Type::F32Matrix,     "I8Matrix"},
+    {Variant::Type::F32Matrix,     "F32Matrix"},
-    {Variant::Type::F64Matrix,     "UI8Matrix"},
+    {Variant::Type::F64Matrix,     "F64Matrix"},
 };
 
 template<typename T>
@@ -195,9 +196,12 @@ void deserializeVariant(const pugi::xml_node &node, Variant &variant, const Byte
     std::string type = node.attribute("type").as_string();
     Variant::Type typeId = typeToId[type];
 
-    if(typeId == Variant::Type::String && !node.attribute("location"))
+    if(typeId == Variant::Type::String)
     {
+        if(!node.attribute("location"))
             variant.setValue(node.text().as_string());
+        else
+            variant.setValue(String(data.constData(), data.size()));
     }
     else if(node.attribute("value"))
     {
@@ -399,6 +403,7 @@ Variant variantFromString(Variant::Type type, const String &str)
 
 Variant::Type Variant::type() const
 {
+    int idx = _value.index();
     return (Variant::Type)_value.index();
 }
 
@@ -429,6 +434,32 @@ String Variant::toString() const
         return ss.str();
     };
 
+    auto matrixString = [](auto matrix) {
+        std::stringstream ss;
+        ss << "{";
+        for(int i=0; i<matrix.rows(); i++)
+        {
+            ss << "{";
+            for(int o=0; o<matrix.cols(); o++)
+            {
+#if __GNUC__ >= 11 || __clang__
+                char str[128] = {0};
+                char *end = str + sizeof(str);
+                std::to_chars(str, end, matrix(i, o));
+                ss << str;
+#else
+                ss << std::to_string(matrix(i, o));
+#endif
+                if(o < matrix.cols() - 1)
+                    ss << ",";
+            }
+            ss << "}";
+            if(i < matrix.rows() - 1)
+                ss << ",";
+        }
+        return ss.str();
+    };
+
     switch(type())
     {
     case Variant::Type::Int8: toChars<Int8>(_value, str, end); break;
@@ -453,6 +484,8 @@ String Variant::toString() const
     case Variant::Type::UI64Vector: string = vectorString(std::get<UI64Vector>(_value)); break;
     case Variant::Type::F32Vector: string = vectorString(std::get<F32Vector>(_value)); break;
     case Variant::Type::F64Vector: string = vectorString(std::get<F64Vector>(_value)); break;
+    case Variant::Type::F32Matrix: string = matrixString(std::get<F32Matrix>(_value)); break;
+    case Variant::Type::F64Matrix: string = matrixString(std::get<F64Matrix>(_value)); break;
     case Variant::Type::String: string = std::get<String>(_value); break;
     case Variant::Type::TimePoint:
     {