libCZI_compress.h

// SPDX-FileCopyrightText: 2017-2022 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <memory>
#include <cstdint>
#include <functional>
#include <map>
#include <type_traits>
#include "libCZI.h"
 
namespace libCZI
{
    enum class CompressionParameterKey
    {
        ZSTD_RAWCOMPRESSIONLEVEL = 1,
 
        ZSTD_PREPROCESS_DOLOHIBYTEPACKING = 2,
 
        JXRLIB_QUALITY = 3,
    };
 
    struct LIBCZI_API CompressParameter
    {
        enum class Type
        {
            Invalid,    
            Int32,      
            Uint32,     
            Boolean     
        };
 
        CompressParameter() : type(Type::Invalid)
        {
        }
 
        explicit CompressParameter(std::int32_t v)
        {
            this->SetInt32(v);
        }
 
        explicit CompressParameter(std::uint32_t v)
        {
            this->SetUInt32(v);
        }
 
        explicit CompressParameter(bool v)
        {
            this->SetBoolean(v);
        }
 
        void SetInt32(std::int32_t v)
        {
            this->type = Type::Int32;
            this->int32Value = v;
        }
 
        void SetUInt32(std::uint32_t v)
        {
            this->type = Type::Uint32;
            this->uint32Value = v;
        }
 
        void SetBoolean(bool v)
        {
            this->type = Type::Boolean;
            this->boolValue = v;
        }
 
        Type GetType() const { return this->type; }
 
        std::int32_t GetInt32() const
        {
            this->ThrowIfTypeIsUnequalTo(Type::Int32);
            return this->int32Value;
        }
 
        std::uint32_t GetUInt32() const
        {
            this->ThrowIfTypeIsUnequalTo(Type::Uint32);
            return this->uint32Value;
        }
 
        bool GetBoolean() const
        {
            this->ThrowIfTypeIsUnequalTo(Type::Boolean);
            return this->boolValue;
        }
    private:
        Type type;  
 
        union
        {
            std::int32_t int32Value;
            std::uint32_t uint32Value;
            bool boolValue;
        };
 
        void ThrowIfTypeIsUnequalTo(Type typeToCheck) const
        {
            if (this->type != typeToCheck)
            {
                throw std::runtime_error("Unexpected type encountered.");
            }
        }
    };
 
    class LIBCZI_API ICompressParameters
    {
    public:
        virtual bool TryGetProperty(int key, CompressParameter* parameter) const = 0;
 
        virtual ~ICompressParameters() = default;
 
        bool TryGetProperty(libCZI::CompressionParameterKey key, CompressParameter* parameter) const
        {
            return this->TryGetProperty(static_cast<typename std::underlying_type<libCZI::CompressionParameterKey>::type>(key), parameter);
        }
    };
 
    class LIBCZI_API IMemoryBlock
    {
    public:
        virtual void* GetPtr() = 0;
 
        virtual size_t GetSizeOfData() const = 0;
 
        virtual ~IMemoryBlock() = default;
    };
 
    class LIBCZI_API ZstdCompress
    {
    public:
        static size_t CalculateMaxCompressedSizeZStd0(std::uint32_t sourceWidth, std::uint32_t sourceHeight, libCZI::PixelType sourcePixeltype);
 
        static bool CompressZStd0(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            const std::function<void* (size_t)>& allocateTempBuffer,
            const std::function<void(void*)>& freeTempBuffer,
            void* destination,
            size_t& sizeDestination,
            const ICompressParameters* parameters);
 
        static std::shared_ptr<IMemoryBlock> CompressZStd0Alloc(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            const std::function<void* (size_t)>& allocateTempBuffer,
            const std::function<void(void*)>& freeTempBuffer,
            const ICompressParameters* parameters);
 
        static bool CompressZStd0(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            void* destination,
            size_t& sizeDestination,
            const ICompressParameters* parameters);
 
        static std::shared_ptr<IMemoryBlock> CompressZStd0Alloc(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            const ICompressParameters* parameters);
 
        static size_t CalculateMaxCompressedSizeZStd1(std::uint32_t sourceWidth, std::uint32_t sourceHeight, libCZI::PixelType sourcePixeltype);
 
        static bool CompressZStd1(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            const std::function<void* (size_t)>& allocateTempBuffer,
            const std::function<void(void*)>& freeTempBuffer,
            void* destination,
            size_t& sizeDestination,
            const ICompressParameters* parameters);
 
        static std::shared_ptr<IMemoryBlock> CompressZStd1Alloc(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            const std::function<void* (size_t)>& allocateTempBuffer,
            const std::function<void(void*)>& freeTempBuffer,
            const ICompressParameters* parameters);
 
        static bool CompressZStd1(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            void* destination,
            size_t& sizeDestination,
            const ICompressParameters* parameters);
 
        static std::shared_ptr<IMemoryBlock> CompressZStd1Alloc(
            std::uint32_t sourceWidth,
            std::uint32_t sourceHeight,
            std::uint32_t sourceStride,
            libCZI::PixelType sourcePixeltype,
            const void* source,
            const ICompressParameters* parameters);
    };
 
    class LIBCZI_API JxrLibCompress
    {
    public:
        static std::shared_ptr<IMemoryBlock> Compress(
            libCZI::PixelType pixel_type, 
            std::uint32_t width, 
            std::uint32_t height, 
            std::uint32_t stride, 
            const void* ptrData,
            const ICompressParameters* parameters);
    };
 
    class LIBCZI_API CompressParametersOnMap : public ICompressParameters
    {
    public:
        std::map<int, CompressParameter> map;   
 
        bool TryGetProperty(int key, CompressParameter* parameter) const override
        {
            const auto it = this->map.find(key);
            if (it != this->map.cend())
            {
                if (parameter != nullptr)
                {
                    *parameter = it->second;
                }
 
                return true;
            }
 
            return false;
        }
    };
}