Jbl/1013574 pyramidtype

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW) # enable new "MSVC runtime library selection" (https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html)
 
 project(libCZI 
-      VERSION 0.51.1
+      VERSION 0.52.0
       HOMEPAGE_URL "https://github.com/ZEISS/libczi"
       DESCRIPTION "libCZI is an Open Source Cross-Platform C++ library to read and write CZI")
 

Src/libCZI/CZIReader.cpp

@@ -113,6 +113,7 @@
             info.logicalRect = IntRect{ entry.x,entry.y,entry.width,entry.height };
             info.physicalSize = IntSize{ (std::uint32_t)entry.storedWidth, (std::uint32_t)entry.storedHeight };
             info.mIndex = entry.mIndex;
+            info.pyramidType = CziUtils::PyramidTypeFromByte(entry.pyramid_type_from_spare);
             return funcEnum(index, info);
         });
 }
@@ -130,6 +131,7 @@
             info.logicalRect = IntRect{ entry.x,entry.y,entry.width,entry.height };
             info.physicalSize = IntSize{ (std::uint32_t)entry.storedWidth, (std::uint32_t)entry.storedHeight };
             info.mIndex = entry.mIndex;
+            info.pyramidType = CziUtils::PyramidTypeFromByte(entry.pyramid_type_from_spare);
             info.filePosition = entry.FilePosition;
             return funcEnum(index, info);
         });
@@ -232,6 +234,7 @@
         info->logicalRect = IntRect{ entry.x,entry.y,entry.width,entry.height };
         info->physicalSize = IntSize{ static_cast<std::uint32_t>(entry.storedWidth), static_cast<std::uint32_t>(entry.storedHeight) };
         info->mIndex = entry.mIndex;
+        info->pyramidType = CziUtils::PyramidTypeFromByte(entry.pyramid_type_from_spare);
     }
 
     return true;
@@ -266,7 +269,7 @@
         });
 }
 
-/*virtual*/void CCZIReader::EnumerateSubset(const char* contentFileType, const char* name, const std::function<bool(int index, const libCZI::AttachmentInfo& infi)>& funcEnum)
+/*virtual*/void CCZIReader::EnumerateSubset(const char* contentFileType, const char* name, const std::function<bool(int index, const libCZI::AttachmentInfo& info)>& funcEnum)
 {
     this->ThrowIfNotOperational();
     libCZI::AttachmentInfo ai;
@@ -315,6 +318,7 @@
     info.mIndex = subBlkData.mIndex;
     info.logicalRect = subBlkData.logicalRect;
     info.physicalSize = subBlkData.physicalSize;
+    info.pyramidType = CziUtils::PyramidTypeFromByte(subBlkData.spare[0]);
 
     return std::make_shared<CCziSubBlock>(info, subBlkData, free);
 }

Src/libCZI/CZIReader.h

@@ -43,7 +43,7 @@ class CCZIReader : public libCZI::ICZIReader, public std::enable_shared_from_thi
     void Close() override;
 
     // interface IAttachmentRepository
-    void EnumerateAttachments(const std::function<bool(int index, const libCZI::AttachmentInfo& infi)>& funcEnum) override;
+    void EnumerateAttachments(const std::function<bool(int index, const libCZI::AttachmentInfo& info)>& funcEnum) override;
     void EnumerateSubset(const char* contentFileType, const char* name, const std::function<bool(int index, const libCZI::AttachmentInfo& infi)>& funcEnum) override;
     std::shared_ptr<libCZI::IAttachment> ReadAttachment(int index) override;
 

Src/libCZI/CziParse.cpp

@@ -281,6 +281,7 @@ using namespace libCZI;
         sbd.compression = subBlckSegment.data.entryDV.Compression;
         sbd.pixelType = subBlckSegment.data.entryDV.PixelType;
         sbd.mIndex = (std::numeric_limits<int>::max)();
+        memcpy(sbd.spare, subBlckSegment.data.entryDV._spare, sizeof(sbd.spare));
 
         if (subBlckSegment.data.entryDV.DimensionCount > MAXDIMENSIONS)
         {
@@ -616,6 +617,7 @@ using namespace libCZI;
     entry.FilePosition = subBlkDirDV->FilePosition;
     entry.PixelType = subBlkDirDV->PixelType;
     entry.Compression = subBlkDirDV->Compression;
+    entry.pyramid_type_from_spare = subBlkDirDV->_spare[0];
 
     addFunc(entry);
 }

Src/libCZI/CziParse.h

@@ -160,6 +160,7 @@ class CCZIParse
         libCZI::IntRect         logicalRect;
         libCZI::IntSize         physicalSize;
         int                     mIndex;         // if not present, then this is int::max
+        std::uint8_t            spare[6];   
     };
 
     static SubBlockData ReadSubBlock(libCZI::IStream* str, std::uint64_t offset, const SubBlockStorageAllocate& allocateInfo);

Src/libCZI/CziReaderWriter.cpp

@@ -677,6 +677,7 @@
     info.mIndex = subBlkData.mIndex;
     info.logicalRect = subBlkData.logicalRect;
     info.physicalSize = subBlkData.physicalSize;
+    info.pyramidType = CziUtils::PyramidTypeFromByte(subBlkData.spare[0]);
 
     return std::make_shared<CCziSubBlock>(info, subBlkData, free);
 }
@@ -698,6 +699,7 @@
         info->logicalRect = IntRect{ entry.x,entry.y,entry.width,entry.height };
         info->physicalSize = IntSize{ static_cast<std::uint32_t>(entry.storedWidth), static_cast<std::uint32_t>(entry.storedHeight) };
         info->mIndex = entry.mIndex;
+        info->pyramidType = CziUtils::PyramidTypeFromByte(entry.pyramid_type_from_spare);
     }
 
     return true;

Src/libCZI/CziReaderWriter.h

@@ -50,7 +50,7 @@ class CCziReaderWriter : public libCZI::ICziReaderWriter
 
     // interface IAttachmentRepository
     void EnumerateAttachments(const std::function<bool(int index, const libCZI::AttachmentInfo& info)>& funcEnum) override;
-    void EnumerateSubset(const char* contentFileType, const char* name, const std::function<bool(int index, const libCZI::AttachmentInfo& infi)>& funcEnum) override;
+    void EnumerateSubset(const char* contentFileType, const char* name, const std::function<bool(int index, const libCZI::AttachmentInfo& info)>& funcEnum) override;
     std::shared_ptr<libCZI::IAttachment> ReadAttachment(int index) override;
 
 private:

Src/libCZI/CziStructs.h

@@ -179,7 +179,16 @@ struct PACKED SubBlockDirectoryEntryDV
     std::int64_t FilePosition;
     std::int32_t FilePart;
     std::int32_t Compression;
-    unsigned char _spare[6];
+
+    /// _spare[0] seems to contain information about the "pyramid-type", where valid values are
+    /// 
+    /// 0: None
+    /// 1: SingleSubblock  
+    /// 2: MultiSubblock  
+    /// 
+    /// The significance and importance of this field is unclear, and it seems of questionable use. It is
+    /// considered legacy and should not be used.
+    std::uint8_t _spare[6];
     std::int32_t DimensionCount;
 
     // max. allocation for ease of use (valid size = 32 + EntryCount * 20)

Src/libCZI/CziSubBlockDirectory.h

@@ -27,6 +27,7 @@ class CCziSubBlockDirectoryBase
         int PixelType;
         std::uint64_t FilePosition;
         int Compression;
+        std::uint8_t pyramid_type_from_spare;   ///< The field "pyramid-type" (from spare-bytes of the subblock-directory-entry)
 
         bool IsMIndexValid() const
         {
@@ -41,6 +42,7 @@ class CCziSubBlockDirectoryBase
         void Invalidate()
         {
             this->mIndex = this->x = this->y = this->width = this->height = this->storedWidth = this->storedHeight = (std::numeric_limits<int>::min)();
+            this->pyramid_type_from_spare = 0;
         }
     };
 

Src/libCZI/CziUtils.cpp

@@ -28,6 +28,30 @@
     return PixelType::Invalid;
 }
 
+/*static*/libCZI::SubBlockPyramidType CziUtils::PyramidTypeFromByte(std::uint8_t byte)
+{
+    switch (byte)
+    {
+    case 0: return SubBlockPyramidType::None;
+    case 1: return SubBlockPyramidType::SingleSubBlock;
+    case 2: return SubBlockPyramidType::MultiSubBlock;
+    }
+
+    return SubBlockPyramidType::Invalid;
+}
+
+/*static*/std::uint8_t CziUtils::ByteFromPyramidType(libCZI::SubBlockPyramidType pyramid_type)
+{
+    switch (pyramid_type)
+    {
+    case SubBlockPyramidType::None: return 0;
+    case SubBlockPyramidType::SingleSubBlock: return 1;
+    case SubBlockPyramidType::MultiSubBlock: return 2;
+    }
+
+    return 0;
+}
+
 /*static*/int CziUtils::IntFromPixelType(libCZI::PixelType p)
 {
     switch (p)

Src/libCZI/CziUtils.h

@@ -20,6 +20,8 @@ class CziUtils
 {
 public:
     static libCZI::PixelType PixelTypeFromInt(int i);
+    static libCZI::SubBlockPyramidType PyramidTypeFromByte(std::uint8_t byte);
+    static std::uint8_t ByteFromPyramidType(libCZI::SubBlockPyramidType pyramid_type);
     static int IntFromPixelType(libCZI::PixelType);
     static libCZI::CompressionMode CompressionModeFromInt(int i);
     static std::int32_t CompressionModeToInt(libCZI::CompressionMode m);

Src/libCZI/CziWriter.cpp

@@ -31,21 +31,21 @@
     AddSubBlockInfo addSbInfo(addSbBlkInfo);
     addSbInfo.sizeData = addSbBlkInfo.dataSize;
     addSbInfo.getData = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        return SetIfCallCountZero(callCnt, addSbBlkInfo.ptrData, addSbBlkInfo.dataSize, ptr, size);
-    };
+        {
+            return SetIfCallCountZero(callCnt, addSbBlkInfo.ptrData, addSbBlkInfo.dataSize, ptr, size);
+        };
 
     addSbInfo.sizeAttachment = addSbBlkInfo.sbBlkAttachmentSize;
     addSbInfo.getAttachment = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        return SetIfCallCountZero(callCnt, addSbBlkInfo.ptrSbBlkAttachment, addSbBlkInfo.sbBlkAttachmentSize, ptr, size);
-    };
+        {
+            return SetIfCallCountZero(callCnt, addSbBlkInfo.ptrSbBlkAttachment, addSbBlkInfo.sbBlkAttachmentSize, ptr, size);
+        };
 
     addSbInfo.sizeMetadata = addSbBlkInfo.sbBlkMetadataSize;
     addSbInfo.getMetaData = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        return SetIfCallCountZero(callCnt, addSbBlkInfo.ptrSbBlkMetadata, addSbBlkInfo.sbBlkMetadataSize, ptr, size);
-    };
+        {
+            return SetIfCallCountZero(callCnt, addSbBlkInfo.ptrSbBlkMetadata, addSbBlkInfo.sbBlkMetadataSize, ptr, size);
+        };
 
     return this->SyncAddSubBlock(addSbInfo);
 }
@@ -58,28 +58,28 @@
     addSbInfo.sizeData = addSbInfoLinewise.physicalHeight * stride;
     auto linesCnt = addSbInfoLinewise.physicalHeight;
     addSbInfo.getData = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        if (callCnt < linesCnt)
         {
-            ptr = addSbInfoLinewise.getBitmapLine(callCnt);
-            size = stride;
-            return true;
-        }
+            if (callCnt < linesCnt)
+            {
+                ptr = addSbInfoLinewise.getBitmapLine(callCnt);
+                size = stride;
+                return true;
+            }
 
-        return false;
-    };
+            return false;
+        };
 
     addSbInfo.sizeAttachment = addSbInfoLinewise.sbBlkAttachmentSize;
     addSbInfo.getAttachment = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        return SetIfCallCountZero(callCnt, addSbInfoLinewise.ptrSbBlkAttachment, addSbInfoLinewise.sbBlkAttachmentSize, ptr, size);
-    };
+        {
+            return SetIfCallCountZero(callCnt, addSbInfoLinewise.ptrSbBlkAttachment, addSbInfoLinewise.sbBlkAttachmentSize, ptr, size);
+        };
 
     addSbInfo.sizeMetadata = addSbInfoLinewise.sbBlkMetadataSize;
     addSbInfo.getMetaData = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        return SetIfCallCountZero(callCnt, addSbInfoLinewise.ptrSbBlkMetadata, addSbInfoLinewise.sbBlkMetadataSize, ptr, size);
-    };
+        {
+            return SetIfCallCountZero(callCnt, addSbInfoLinewise.ptrSbBlkMetadata, addSbInfoLinewise.sbBlkMetadataSize, ptr, size);
+        };
 
     return this->SyncAddSubBlock(addSbInfo);
 }
@@ -90,28 +90,28 @@
 
     addSbInfo.sizeData = addSbBlkInfoStrideBitmap.physicalHeight * (addSbBlkInfoStrideBitmap.physicalWidth * (size_t)CziUtils::GetBytesPerPel(addSbBlkInfoStrideBitmap.PixelType));
     addSbInfo.getData = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        if (callCnt < addSbBlkInfoStrideBitmap.physicalHeight)
         {
-            ptr = static_cast<const char*>(addSbBlkInfoStrideBitmap.ptrBitmap) + callCnt * (size_t)addSbBlkInfoStrideBitmap.strideBitmap;
-            size = addSbBlkInfoStrideBitmap.physicalWidth * (size_t)CziUtils::GetBytesPerPel(addSbBlkInfoStrideBitmap.PixelType);
-            return true;
-        }
+            if (callCnt < addSbBlkInfoStrideBitmap.physicalHeight)
+            {
+                ptr = static_cast<const char*>(addSbBlkInfoStrideBitmap.ptrBitmap) + callCnt * (size_t)addSbBlkInfoStrideBitmap.strideBitmap;
+                size = addSbBlkInfoStrideBitmap.physicalWidth * (size_t)CziUtils::GetBytesPerPel(addSbBlkInfoStrideBitmap.PixelType);
+                return true;
+            }
 
-        return false;
-    };
+            return false;
+        };
 
     addSbInfo.sizeAttachment = addSbBlkInfoStrideBitmap.sbBlkAttachmentSize;
     addSbInfo.getAttachment = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        return SetIfCallCountZero(callCnt, addSbBlkInfoStrideBitmap.ptrSbBlkAttachment, addSbBlkInfoStrideBitmap.sbBlkAttachmentSize, ptr, size);
-    };
+        {
+            return SetIfCallCountZero(callCnt, addSbBlkInfoStrideBitmap.ptrSbBlkAttachment, addSbBlkInfoStrideBitmap.sbBlkAttachmentSize, ptr, size);
+        };
 
     addSbInfo.sizeMetadata = addSbBlkInfoStrideBitmap.sbBlkMetadataSize;
     addSbInfo.getMetaData = [&](int callCnt, size_t offset, const void*& ptr, size_t& size)->bool
-    {
-        return SetIfCallCountZero(callCnt, addSbBlkInfoStrideBitmap.ptrSbBlkMetadata, addSbBlkInfoStrideBitmap.sbBlkMetadataSize, ptr, size);
-    };
+        {
+            return SetIfCallCountZero(callCnt, addSbBlkInfoStrideBitmap.ptrSbBlkMetadata, addSbBlkInfoStrideBitmap.sbBlkMetadataSize, ptr, size);
+        };
 
     return this->SyncAddSubBlock(addSbInfo);
 }
@@ -269,7 +269,8 @@
     ptr->PixelType = CziUtils::IntFromPixelType(addSbBlkInfo.PixelType);
     ptr->FilePosition = ptr->FilePart = 0;
     ptr->Compression = addSbBlkInfo.compressionModeRaw;
-    memset(ptr->_spare, 0, sizeof(ptr->_spare));
+    ptr->_spare[0] = CziUtils::ByteFromPyramidType(addSbBlkInfo.pyramid_type);
+    memset(ptr->_spare + 1, 0, sizeof(ptr->_spare) - 1);
     ptr->DimensionCount = CalcCountOfDimensionsEntriesInDirectoryEntryDV(addSbBlkInfo);
 
     // first X and Y
@@ -331,7 +332,8 @@
     ptr->FilePosition = entry.FilePosition;
     ptr->FilePart = 0;
     ptr->Compression = entry.Compression;
-    memset(ptr->_spare, 0, sizeof(ptr->_spare));
+    ptr->_spare[0] = entry.pyramid_type_from_spare;
+    memset(ptr->_spare + 1, 0, sizeof(ptr->_spare) - 1);    // skipping the pyramid-spare-byte we set above here
     ptr->DimensionCount = CalcCountOfDimensionsEntriesInDirectoryEntryDV(entry);
 
     // first X and Y
@@ -829,6 +831,7 @@
     entry.PixelType = CziUtils::IntFromPixelType(addSbBlkInfo.PixelType);
     entry.FilePosition = 0;
     entry.Compression = addSbBlkInfo.compressionModeRaw;
+    entry.pyramid_type_from_spare = CziUtils::ByteFromPyramidType(addSbBlkInfo.pyramid_type);
     return entry;
 }
 
@@ -1176,13 +1179,13 @@
     info.segmentPosForNewSegment = this->nextSegmentPos;
     info.entryCnt = this->attachmentDirectory.GetAttachmentCount();
     info.enumEntriesFunc = [&](const std::function<void(size_t, const CCziAttachmentsDirectoryBase::AttachmentEntry&)>& f)->void
-    {
-        this->attachmentDirectory.EnumEntries([&](size_t index, const CCziAttachmentsDirectoryBase::AttachmentEntry& e)->bool
-            {
-                f(index, e);
-                return true;
-            });
-    };
+        {
+            this->attachmentDirectory.EnumEntries([&](size_t index, const CCziAttachmentsDirectoryBase::AttachmentEntry& e)->bool
+                {
+                    f(index, e);
+                    return true;
+                });
+        };
     info.writeFunc = std::bind(&CCziWriter::WriteToOutputStream, this, placeholders::_1, placeholders::_2, placeholders::_3, placeholders::_4, placeholders::_5);
     auto posAndSize = CWriterUtils::WriteAttachmentDirectory(info);
     if (get<0>(posAndSize) == info.segmentPosForNewSegment)
@@ -1217,13 +1220,13 @@
 
     info.segmentPosForNewSegment = this->nextSegmentPos;
     info.enumEntriesFunc = [&](const std::function<void(size_t, const CCziSubBlockDirectoryBase::SubBlkEntry&)>& f)->void
-    {
-        this->sbBlkDirectory.EnumEntries([&](size_t index, const CCziSubBlockDirectoryBase::SubBlkEntry& e)->bool
-            {
-                f(index, e);
-                return true;
-            });
-    };
+        {
+            this->sbBlkDirectory.EnumEntries([&](size_t index, const CCziSubBlockDirectoryBase::SubBlkEntry& e)->bool
+                {
+                    f(index, e);
+                    return true;
+                });
+        };
     info.writeFunc = std::bind(&CCziWriter::WriteToOutputStream, this, placeholders::_1, placeholders::_2, placeholders::_3, placeholders::_4, placeholders::_5);
     auto posAndSize = CWriterUtils::WriteSubBlkDirectory(info);
     if (get<0>(posAndSize) == info.segmentPosForNewSegment)

Src/libCZI/libCZI.h

@@ -231,6 +231,10 @@ namespace libCZI
         /// The M-index of the sub-block (if available). If not available, it has the value std::numeric_limits<int>::max() or std::numeric_limits<int>::min().
         int                     mIndex;
 
+        /// This field indicates the "pyramid-type" of the sub-block. The significance and importance of this field is unclear, and is considered
+        /// legacy. It is recommended to ignore this field.
+        SubBlockPyramidType     pyramidType;
+
         /// Calculate a zoom-factor from the physical- and logical size.
         /// \remark
         /// This calculation not really well-defined.
@@ -351,7 +355,7 @@ namespace libCZI
         /// \return The raw data.
         virtual std::shared_ptr<const void> GetRawData(size_t* ptrSize) = 0;
 
-        virtual ~IAttachment() {}
+        virtual ~IAttachment() = default;
 
         /// A helper method used to cast the pointer to a specific type.
         /// \param [out] ptr     The pointer to the data is stored here.
@@ -595,7 +599,7 @@ namespace libCZI
         ///                 functor is true, the enumeration is continued, otherwise it is stopped.
         ///                 The first argument is the index of the attachment and the second is providing
         ///                 information about the attachment.
-        virtual void EnumerateSubset(const char* contentFileType, const char* name, const std::function<bool(int index, const AttachmentInfo& infi)>& funcEnum) = 0;
+        virtual void EnumerateSubset(const char* contentFileType, const char* name, const std::function<bool(int index, const AttachmentInfo& info)>& funcEnum) = 0;
 
         /// Reads the attachment identified by the specified index. If there is no attachment present (for
         /// the specified index) then an empty shared_ptr is returned. If a different kind of problem