fzm_format.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <cstring>
#include <stdexcept>
#include <string>
 
namespace fz {
 
constexpr uint32_t FZM_MAGIC = 0x464D5A32;
 
constexpr uint8_t  FZM_VERSION_MAJOR = 3;
constexpr uint8_t  FZM_VERSION_MINOR = 1;
constexpr uint16_t FZM_VERSION = (static_cast<uint16_t>(FZM_VERSION_MAJOR) << 8)
                                | static_cast<uint16_t>(FZM_VERSION_MINOR);
 
constexpr size_t FZM_LEGACY_HEADER_CORE_SIZE = 72;
 
constexpr uint16_t FZM_FLAG_HAS_DATA_CHECKSUM   = 0x0001u;  
constexpr uint16_t FZM_FLAG_HAS_HEADER_CHECKSUM = 0x0002u;  
 
constexpr uint8_t fzmVersionMajor(uint16_t v) {
    return (v <= 0xFF) ? static_cast<uint8_t>(v) : static_cast<uint8_t>(v >> 8);
}
constexpr uint8_t fzmVersionMinor(uint16_t v) {
    return (v <= 0xFF) ? 0u : static_cast<uint8_t>(v & 0xFF);
}
 
constexpr size_t FZM_MAX_BUFFERS      = 32;   
constexpr size_t FZM_MAX_NAME_LEN     = 64;   
constexpr size_t FZM_STAGE_CONFIG_SIZE = 128; 
constexpr size_t FZM_MAX_SOURCES      = 4;    
 
// ─────────────────────────────────────────────────────────────────────────────
 
enum class StageType : uint16_t {
    UNKNOWN    = 0,
    LORENZO_1D = 1,   
    DIFFERENCE = 2,   
    SCALE      = 3,   
    PASSTHROUGH= 4,   
    RLE        = 5,   
    HUFFMAN    = 6,   
    BITPACK    = 7,   
    SPLIT      = 10,  
    MERGE      = 11,  
    LORENZO_2D = 12,  
    LORENZO_3D = 13,  
    QUANTIZER  = 14,  
    ZIGZAG     = 15,  
    NEGABINARY = 16,  
    BITSHUFFLE = 17,  
    RZE        = 18,  
};
 
enum class DataType : uint8_t {
    UINT8   = 0,
    UINT16  = 1,
    UINT32  = 2,
    UINT64  = 3,
    INT8    = 4,
    INT16   = 5,
    INT32   = 6,
    INT64   = 7,
    FLOAT32 = 8,
    FLOAT64 = 9,
    UNKNOWN = 0xFF,  
};
 
// ─────────────────────────────────────────────────────────────────────────────
 
constexpr size_t FZM_MAX_STAGE_INPUTS  = 8;
constexpr size_t FZM_MAX_STAGE_OUTPUTS = 8;
 
struct FZMStageInfo {
    StageType stage_type;     
    uint16_t  stage_version;  
    uint8_t   num_inputs;     
    uint8_t   num_outputs;    
    uint16_t  reserved1;      
 
    uint16_t input_buffer_ids[FZM_MAX_STAGE_INPUTS];   
    uint16_t output_buffer_ids[FZM_MAX_STAGE_OUTPUTS]; 
 
    uint8_t  stage_config[FZM_STAGE_CONFIG_SIZE]; 
    uint32_t config_size;  
 
    uint8_t reserved2[84]; 
    // Total: 2+2+1+1+2+16+16+128+4+84 = 256 bytes
 
    FZMStageInfo() {
        stage_type   = StageType::UNKNOWN;
        stage_version = 0;
        num_inputs   = 0;
        num_outputs  = 0;
        reserved1    = 0;
        memset(input_buffer_ids,  0xFF, sizeof(input_buffer_ids));
        memset(output_buffer_ids, 0xFF, sizeof(output_buffer_ids));
        memset(stage_config, 0, FZM_STAGE_CONFIG_SIZE);
        config_size = 0;
        memset(reserved2, 0, 84);
    }
};
static_assert(sizeof(FZMStageInfo) == 256, "FZMStageInfo must be 256 bytes");
 
struct FZMBufferEntry {
    StageType stage_type;         
    uint16_t  stage_version;      
    DataType  data_type;          
    uint8_t   producer_output_idx;
    uint16_t  dag_buffer_id;      
    char      name[FZM_MAX_NAME_LEN]; 
 
    uint64_t  data_size;          
    uint64_t  allocated_size;     
    uint64_t  uncompressed_size;  
    uint64_t  byte_offset;        
 
    uint8_t  stage_config[FZM_STAGE_CONFIG_SIZE]; 
    uint32_t config_size; 
 
    uint8_t reserved2[14]; 
    // Total: 2+2+1+1+2+64+8+8+8+8+128+4+14 = 250... let me recount
    // 2+2+1+1+2+64+8+8+8+8+128+4+14 = 250? No...
    // stage_type(2)+stage_version(2)+data_type(1)+producer_output_idx(1)+dag_buffer_id(2)+name(64)
    // +data_size(8)+allocated_size(8)+uncompressed_size(8)+byte_offset(8)
    // +stage_config(128)+config_size(4)+reserved2(14) = 250. Hmm, the static_assert says 256.
    // Let me check the original: 2+2+1+1+2+64+8+8+8+8+128+4+14 = 250. But static_assert says 256.
    // There might be padding. Let me just keep it as-is.
 
    FZMBufferEntry() {
        stage_type         = StageType::UNKNOWN;
        stage_version      = 0;
        data_type          = DataType::UINT8;
        producer_output_idx = 0;
        dag_buffer_id      = 0xFFFF;
        memset(name, 0, FZM_MAX_NAME_LEN);
        data_size          = 0;
        allocated_size     = 0;
        uncompressed_size  = 0;
        byte_offset        = 0;
        memset(stage_config, 0, FZM_STAGE_CONFIG_SIZE);
        config_size        = 0;
        memset(reserved2, 0, 14);
    }
};
static_assert(sizeof(FZMBufferEntry) == 256, "FZMBufferEntry must be 256 bytes");
 
struct FZMHeaderCore {
    uint32_t magic;             
    uint16_t version;           
    uint16_t num_buffers;       
 
    uint64_t uncompressed_size; 
    uint64_t compressed_size;   
    uint64_t header_size;       
 
    uint32_t num_stages;        
    uint16_t num_sources;       
    uint16_t flags;             
 
    uint64_t source_uncompressed_sizes[FZM_MAX_SOURCES]; 
 
    uint32_t data_checksum;   
    uint32_t header_checksum; 
    // Total: 4+2+2+8+8+8+4+2+2+32+4+4 = 80 bytes
 
    FZMHeaderCore() {
        magic              = FZM_MAGIC;
        version            = FZM_VERSION;
        num_buffers        = 0;
        uncompressed_size  = 0;
        compressed_size    = 0;
        header_size        = sizeof(FZMHeaderCore);
        num_stages         = 0;
        num_sources        = 0;
        flags              = 0;
        memset(source_uncompressed_sizes, 0, sizeof(source_uncompressed_sizes));
        data_checksum      = 0;
        header_checksum    = 0;
    }
 
    uint64_t computeHeaderSize() const {
        return sizeof(FZMHeaderCore)
             + num_stages  * sizeof(FZMStageInfo)
             + num_buffers * sizeof(FZMBufferEntry);
    }
};
static_assert(sizeof(FZMHeaderCore) == 80, "FZMHeaderCore must be 80 bytes");
 
// ─────────────────────────────────────────────────────────────────────────────
// Helper functions
// ─────────────────────────────────────────────────────────────────────────────
 
inline size_t getDataTypeSize(DataType type) {
    switch (type) {
        case DataType::UINT8:  case DataType::INT8:                        return 1;
        case DataType::UINT16: case DataType::INT16:                       return 2;
        case DataType::UINT32: case DataType::INT32: case DataType::FLOAT32: return 4;
        case DataType::UINT64: case DataType::INT64: case DataType::FLOAT64: return 8;
        default: throw std::runtime_error("Unknown data type");
    }
}
 
inline std::string dataTypeToString(DataType type) {
    switch (type) {
        case DataType::UINT8:   return "uint8";
        case DataType::UINT16:  return "uint16";
        case DataType::UINT32:  return "uint32";
        case DataType::UINT64:  return "uint64";
        case DataType::INT8:    return "int8";
        case DataType::INT16:   return "int16";
        case DataType::INT32:   return "int32";
        case DataType::INT64:   return "int64";
        case DataType::FLOAT32: return "float32";
        case DataType::FLOAT64: return "float64";
        default:                return "unknown";
    }
}
 
inline std::string stageTypeToString(StageType type) {
    switch (type) {
        case StageType::LORENZO_1D:  return "Lorenzo1D";
        case StageType::LORENZO_2D:  return "Lorenzo2D";
        case StageType::LORENZO_3D:  return "Lorenzo3D";
        case StageType::DIFFERENCE:  return "Difference";
        case StageType::SCALE:       return "Scale";
        case StageType::PASSTHROUGH: return "PassThrough";
        case StageType::RLE:         return "RLE";
        case StageType::HUFFMAN:     return "Huffman";
        case StageType::BITPACK:     return "BitPack";
        case StageType::SPLIT:       return "Split";
        case StageType::MERGE:       return "Merge";
        case StageType::QUANTIZER:   return "Quantizer";
        case StageType::ZIGZAG:      return "Zigzag";
        case StageType::NEGABINARY:  return "Negabinary";
        case StageType::BITSHUFFLE:  return "Bitshuffle";
        case StageType::RZE:         return "RZE";
        default:                     return "Unknown";
    }
}
 
} // namespace fz