libCZI_Write.h

// SPDX-FileCopyrightText: 2017-2022 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <string>
#include <tuple>
#include <memory>
#include <limits>
#include "libCZI.h"
 
#if !defined(_LIBCZISTATICLIB) && !defined(__GNUC__)
 
// When used as a DLL, we need to tinker with STL-classes used in exported structs/classes, or we get "warning C4251".
// Note that using a different compiler-version/STL-version is still problematic and should be avoided.
#if defined(LIBCZI_EXPORTS)
    // https://web.archive.org/web/20141227011407/http://support.microsoft.com/kb/168958
    template class LIBCZI_API std::function<bool(int callCnt, size_t offset, const void*& ptr, size_t& size)>;
    template class LIBCZI_API std::function<const void* (int line)>;
#else
    extern template class LIBCZI_API std::function<bool(int callCnt, size_t offset, const void*& ptr, size_t& size)>;
    extern template class LIBCZI_API std::function<const void* (int line)>;
#endif
 
#endif
 
namespace libCZI
{
    class LIBCZI_API ICziWriterInfo
    {
    public:
 
        virtual const IDimBounds* GetDimBounds() const = 0;
 
        virtual const GUID& GetFileGuid() const = 0;
 
        virtual bool TryGetMIndexMinMax(int* min, int* max) const = 0;
 
        virtual bool TryGetReservedSizeForAttachmentDirectory(size_t* size) const = 0;
 
        virtual bool TryGetReservedSizeForSubBlockDirectory(size_t* size) const = 0;
 
        virtual bool TryGetReservedSizeForMetadataSegment(size_t* size) const = 0;
 
        virtual ~ICziWriterInfo() = default;
    };
 
    class LIBCZI_API CCziWriterInfo :public libCZI::ICziWriterInfo
    {
    private:
        bool dimBoundsValid;
        CDimBounds dimBounds;
        GUID fileGuid;          
        bool mBoundsValid;
        int mMin, mMax;
        size_t reservedSizeAttachmentsDir, reservedSizeSubBlkDir, reservedSizeMetadataSegment;
        bool reservedSizeAttachmentsDirValid, reservedSizeSubBlkDirValid, reservedSizeMetadataSegmentValid;
    public:
        CCziWriterInfo() : CCziWriterInfo(GUID{ 0,0,0,{0,0,0,0,0,0,0,0} })
        {}
 
        explicit CCziWriterInfo(const GUID& fileGuid, int mMin = 1, int mMax = -1)
            : fileGuid(fileGuid), reservedSizeAttachmentsDirValid(false), reservedSizeSubBlkDirValid(false), reservedSizeMetadataSegmentValid(false)
        {
            this->SetDimBounds(nullptr);
            this->SetMIndexBounds(mMin, mMax);
        }
 
        CCziWriterInfo(const GUID& fileGuid, const IDimBounds& bounds, int mMin = 1, int mMax = -1)
            : fileGuid(fileGuid), reservedSizeAttachmentsDirValid(false), reservedSizeSubBlkDirValid(false), reservedSizeMetadataSegmentValid(false)
        {
            this->SetDimBounds(&bounds);
            this->SetMIndexBounds(mMin, mMax);
        }
 
        const IDimBounds* GetDimBounds() const override { return this->dimBoundsValid ? &this->dimBounds : nullptr; }
        const GUID& GetFileGuid() const override { return this->fileGuid; }
        bool TryGetMIndexMinMax(int* min, int* max) const override;
        bool TryGetReservedSizeForAttachmentDirectory(size_t* size) const override;
        bool TryGetReservedSizeForSubBlockDirectory(size_t* size) const override;
        bool TryGetReservedSizeForMetadataSegment(size_t* size) const override;
 
        void SetReservedSizeForAttachmentsDirectory(bool reserveSpace, size_t s);
 
        void SetReservedSizeForSubBlockDirectory(bool reserveSpace, size_t s);
 
        void SetReservedSizeForMetadataSegment(bool reserveSpace, size_t s);
 
        void SetDimBounds(const IDimBounds* bounds);
 
        void SetMIndexBounds(int mMin, int mMax);
    };
 
    struct LIBCZI_API AddSubBlockInfoBase
    {
        AddSubBlockInfoBase() { this->AddSubBlockInfoBase::Clear(); }
 
        virtual ~AddSubBlockInfoBase() = default;
 
        libCZI::CDimCoordinate coordinate;          
        bool mIndexValid;                           
        int mIndex;                                 
        int x;                                      
        int y;                                      
        int logicalWidth;                           
        int logicalHeight;                          
        int physicalWidth;                          
        int physicalHeight;                         
        libCZI::PixelType PixelType;                
        libCZI::SubBlockPyramidType pyramid_type;   
 
        std::int32_t compressionModeRaw;
 
        virtual void Clear();
 
        void SetCompressionMode(libCZI::CompressionMode m)
        {
            this->compressionModeRaw = libCZI::Utils::CompressionModeToCompressionIdentifier(m);
        }
 
        libCZI::CompressionMode GetCompressionMode() const
        {
            return libCZI::Utils::CompressionModeFromRawCompressionIdentifier(this->compressionModeRaw);
        }
    };
 
    struct LIBCZI_API AddSubBlockInfo : AddSubBlockInfoBase
    {
        AddSubBlockInfo() : sizeData(0), sizeMetadata(0), sizeAttachment(0) {}
 
        explicit AddSubBlockInfo(const AddSubBlockInfoBase& other) :
            AddSubBlockInfoBase(other), sizeData(0), sizeMetadata(0), sizeAttachment(0)
        {}
 
        size_t sizeData;        
 
        std::function<bool(int callCnt, size_t offset, const void*& ptr, size_t& size)> getData;
 
        size_t sizeMetadata;    
 
        std::function<bool(int callCnt, size_t offset, const void*& ptr, size_t& size)> getMetaData;
 
        size_t sizeAttachment;  
 
        std::function<bool(int callCnt, size_t offset, const void*& ptr, size_t& size)> getAttachment;
 
        void Clear() override;
    };
 
    struct LIBCZI_API AddSubBlockInfoMemPtr : public AddSubBlockInfoBase
    {
        AddSubBlockInfoMemPtr() :
            ptrData(nullptr), dataSize(0), ptrSbBlkMetadata(nullptr), sbBlkMetadataSize(0), ptrSbBlkAttachment(nullptr), sbBlkAttachmentSize(0)
        {}
 
        const void* ptrData;                
        std::uint32_t dataSize;             
 
        const void* ptrSbBlkMetadata;       
        std::uint32_t sbBlkMetadataSize;    
 
        const void* ptrSbBlkAttachment;     
        std::uint32_t sbBlkAttachmentSize;  
 
        void Clear() override;
    };
 
    struct LIBCZI_API AddSubBlockInfoStridedBitmap : public AddSubBlockInfoBase
    {
        AddSubBlockInfoStridedBitmap() :
            ptrBitmap(nullptr), strideBitmap(0), ptrSbBlkMetadata(nullptr), sbBlkMetadataSize(0), ptrSbBlkAttachment(nullptr), sbBlkAttachmentSize(0)
        {}
 
        const void* ptrBitmap;              
        std::uint32_t strideBitmap;         
 
        const void* ptrSbBlkMetadata;       
        std::uint32_t sbBlkMetadataSize;    
 
        const void* ptrSbBlkAttachment;     
        std::uint32_t sbBlkAttachmentSize;  
 
        void Clear() override;
    };
 
    struct LIBCZI_API AddSubBlockInfoLinewiseBitmap : public AddSubBlockInfoBase
    {
        AddSubBlockInfoLinewiseBitmap() :ptrSbBlkMetadata(nullptr), sbBlkMetadataSize(0), ptrSbBlkAttachment(nullptr), sbBlkAttachmentSize(0)
        {}
 
        std::function<const void* (int line)> getBitmapLine;
 
        const void* ptrSbBlkMetadata;       
        std::uint32_t sbBlkMetadataSize;    
 
        const void* ptrSbBlkAttachment;     
        std::uint32_t sbBlkAttachmentSize;  
 
        void Clear() override;
    };
 
    struct LIBCZI_API AddAttachmentInfo
    {
        GUID contentGuid;
 
        std::uint8_t contentFileType[8];
 
        std::uint8_t name[80];
 
        const void* ptrData;    
        std::uint32_t dataSize; 
 
        void SetContentFileType(const char* sz)
        {
            memset(this->contentFileType, 0, sizeof(this->contentFileType));
            const auto len = strlen(sz);
            memcpy(this->contentFileType, sz, (std::min)(sizeof(this->contentFileType), len));
        }
 
        void SetName(const char* sz)
        {
            memset(this->name, 0, sizeof(this->name));
            const auto len = strlen(sz);
            memcpy(this->name, sz, (std::min)(sizeof(this->name), len));
        }
    };
 
    struct LIBCZI_API WriteMetadataInfo
    {
        const char* szMetadata;     
        size_t      szMetadataSize; 
        const void* ptrAttachment;  
        size_t      attachmentSize; 
 
        void Clear() { memset(this, 0, sizeof(*this)); }
    };
 
    struct PrepareMetadataInfo
    {
        std::function<std::tuple<std::string, std::tuple<bool, std::string>>(int)> funcGenerateIdAndNameForChannel;
    };
 
    class LIBCZI_API ICziWriter
    {
    public:
        virtual void Create(std::shared_ptr<IOutputStream> stream, std::shared_ptr<ICziWriterInfo> info) = 0;
 
        virtual void SyncAddSubBlock(const AddSubBlockInfo& addSbBlkInfo) = 0;
 
        virtual void SyncAddAttachment(const AddAttachmentInfo& addAttachmentInfo) = 0;
 
        virtual void SyncWriteMetadata(const WriteMetadataInfo& metadataInfo) = 0;
 
        virtual std::shared_ptr<libCZI::ICziMetadataBuilder> GetPreparedMetadata(const PrepareMetadataInfo& info) = 0;
 
        virtual void Close() = 0;
 
        virtual libCZI::SubBlockStatistics GetStatistics() const = 0;
 
        virtual ~ICziWriter() = default;
 
        void SyncAddSubBlock(const AddSubBlockInfoMemPtr& addSbBlkInfo);
 
        void SyncAddSubBlock(const libCZI::AddSubBlockInfoLinewiseBitmap& addSbInfoLinewise);
 
        void SyncAddSubBlock(const AddSubBlockInfoStridedBitmap& addSbBlkInfoStrideBitmap);
    };
 
    //-------------------------------------------------------------------------------------------
 
    inline void AddSubBlockInfoBase::Clear()
    {
        this->coordinate.Clear();
        this->mIndexValid = false;
        this->x = (std::numeric_limits<int>::min)();
        this->y = (std::numeric_limits<int>::min)();
        this->logicalWidth = 0;
        this->logicalHeight = 0;
        this->physicalWidth = 0;
        this->physicalHeight = 0;
        this->PixelType = libCZI::PixelType::Invalid;
        this->pyramid_type = libCZI::SubBlockPyramidType::None;
        this->SetCompressionMode(CompressionMode::UnCompressed);
    }
 
    inline void AddSubBlockInfoMemPtr::Clear()
    {
        this->AddSubBlockInfoBase::Clear();
        this->ptrData = nullptr;
        this->dataSize = 0;
        this->ptrSbBlkMetadata = nullptr;
        this->sbBlkMetadataSize = 0;
        this->ptrSbBlkAttachment = nullptr;
        this->sbBlkAttachmentSize = 0;
    }
 
    inline void AddSubBlockInfoLinewiseBitmap::Clear()
    {
        this->AddSubBlockInfoBase::Clear();
        this->getBitmapLine = nullptr;
        this->ptrSbBlkMetadata = nullptr;
        this->sbBlkMetadataSize = 0;
        this->ptrSbBlkAttachment = nullptr;
        this->sbBlkAttachmentSize = 0;
    }
 
    inline void AddSubBlockInfo::Clear()
    {
        this->AddSubBlockInfoBase::Clear();
        this->sizeData = 0;
        this->getData = nullptr;
        this->sizeMetadata = 0;
        this->getMetaData = nullptr;
        this->sizeAttachment = 0;
        this->getAttachment = nullptr;
    }
 
    inline void AddSubBlockInfoStridedBitmap::Clear()
    {
        this->AddSubBlockInfoBase::Clear();
        this->ptrBitmap = nullptr;
        this->strideBitmap = 0;
        this->ptrSbBlkMetadata = nullptr;
        this->sbBlkMetadataSize = 0;
        this->ptrSbBlkAttachment = nullptr;
        this->sbBlkAttachmentSize = 0;
    }
 
    inline /*virtual*/bool CCziWriterInfo::TryGetMIndexMinMax(int* min, int* max) const
    {
        if (!this->mBoundsValid)
        {
            return false;
        }
 
        if (min != nullptr) { *min = this->mMin; }
        if (max != nullptr) { *max = this->mMax; }
        return true;
    }
 
    inline /*virtual*/bool CCziWriterInfo::TryGetReservedSizeForAttachmentDirectory(size_t* size) const
    {
        if (this->reservedSizeAttachmentsDirValid)
        {
            if (size != nullptr)
            {
                *size = this->reservedSizeAttachmentsDir;
            }
 
            return true;
        }
 
        return false;
    }
 
    inline /*virtual*/bool CCziWriterInfo::TryGetReservedSizeForSubBlockDirectory(size_t* size) const
    {
        if (this->reservedSizeSubBlkDirValid)
        {
            if (size != nullptr)
            {
                *size = this->reservedSizeSubBlkDir;
            }
 
            return true;
        }
 
        return false;
    }
 
    inline /*virtual*/bool CCziWriterInfo::TryGetReservedSizeForMetadataSegment(size_t* size) const
    {
        if (this->reservedSizeMetadataSegmentValid)
        {
            if (size != nullptr)
            {
                *size = this->reservedSizeMetadataSegment;
            }
 
            return true;
        }
 
        return false;
    }
 
    inline void CCziWriterInfo::SetReservedSizeForAttachmentsDirectory(bool reserveSpace, size_t s)
    {
        this->reservedSizeAttachmentsDirValid = reserveSpace;
        if (reserveSpace)
        {
            this->reservedSizeAttachmentsDir = s;
        }
    }
 
    inline void CCziWriterInfo::SetReservedSizeForSubBlockDirectory(bool reserveSpace, size_t s)
    {
        this->reservedSizeSubBlkDirValid = reserveSpace;
        if (reserveSpace)
        {
            this->reservedSizeSubBlkDir = s;
        }
    }
 
    inline void CCziWriterInfo::SetReservedSizeForMetadataSegment(bool reserveSpace, size_t s)
    {
        this->reservedSizeMetadataSegmentValid = reserveSpace;
        if (reserveSpace)
        {
            this->reservedSizeMetadataSegment = s;
        }
    }
 
    inline void CCziWriterInfo::SetDimBounds(const IDimBounds* bounds)
    {
        if (bounds == nullptr)
        {
            this->dimBoundsValid = false;
        }
        else
        {
            this->dimBounds = CDimBounds(bounds);
            this->dimBoundsValid = true;
        }
    }
 
    inline void CCziWriterInfo::SetMIndexBounds(int mMin, int mMax)
    {
        if (mMax < mMin)
        {
            this->mBoundsValid = false;
        }
        else
        {
            this->mMin = mMin;
            this->mMax = mMax;
            this->mBoundsValid = true;
        }
    }
}