haagenti-zstd 0.1.1

Zstandard-inspired compression for Haagenti (internal format, not Zstd-compatible)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Debug decoding to trace the issue

use haagenti_core::{Compressor, Decompressor};
use haagenti_zstd::{ZstdCompressor, ZstdDecompressor};

fn main() {
    let input = b"ABCDABCDABCDABCD";
    println!(
        "Input: {:?} ({} bytes)",
        String::from_utf8_lossy(input),
        input.len()
    );

    let compressor = ZstdCompressor::new();
    let compressed = compressor.compress(input).unwrap();

    println!("\nCompressed: {} bytes", compressed.len());
    print!("Hex: ");
    for b in &compressed {
        print!("{:02x} ", b);
    }
    println!();

    // Parse sequence section manually to understand the issue
    println!("\n=== Manual parsing ===");

    // Find sequence section
    let mut pos = 4; // skip magic
    let fhd = compressed[pos];
    pos += 1;
    let single_segment = (fhd >> 5) & 1 != 0;
    if !single_segment {
        pos += 1; // window descriptor
    }
    let fcs_flag = (fhd >> 6) & 3;
    let fcs_size = match fcs_flag {
        0 => {
            if single_segment {
                1
            } else {
                0
            }
        }
        1 => 2,
        2 => 4,
        3 => 8,
        _ => 0,
    };
    pos += fcs_size;

    // Block header
    pos += 3; // skip block header

    // Literals
    let lit_byte0 = compressed[pos];
    let size_format = (lit_byte0 >> 2) & 0x03;
    let (header_size, lit_size) = match size_format {
        0 | 1 => (1, (lit_byte0 >> 3) as usize),
        2 => {
            let byte1 = compressed[pos + 1];
            (2, ((lit_byte0 >> 4) as usize) | ((byte1 as usize) << 4))
        }
        _ => (3, 0),
    };
    pos += header_size + lit_size;

    println!("Sequence section starts at pos {}", pos);
    let seq_section = &compressed[pos..];
    println!(
        "Sequence section ({} bytes): {:02x?}",
        seq_section.len(),
        seq_section
    );

    // Parse count
    let count = seq_section[0] as usize;
    println!("Sequence count: {}", count);

    // Parse mode
    let mode_byte = seq_section[1];
    println!("Mode byte: 0x{:02x} = 0b{:08b}", mode_byte, mode_byte);

    // Extract modes (RFC 8878)
    let ll_mode = mode_byte & 0x03;
    let of_mode = (mode_byte >> 2) & 0x03;
    let ml_mode = (mode_byte >> 4) & 0x03;

    let mode_name = |m| match m {
        0 => "Predefined",
        1 => "RLE",
        2 => "FSE",
        3 => "Repeat",
        _ => "Unknown",
    };

    println!("LL mode: {} ({})", ll_mode, mode_name(ll_mode));
    println!("OF mode: {} ({})", of_mode, mode_name(of_mode));
    println!("ML mode: {} ({})", ml_mode, mode_name(ml_mode));

    println!("All RLE? {}", ll_mode == 1 && of_mode == 1 && ml_mode == 1);

    // Try our decoder
    println!("\n=== Our decoder ===");
    let decompressor = ZstdDecompressor;
    match decompressor.decompress(&compressed) {
        Ok(decompressed) => {
            println!("SUCCESS: {} bytes", decompressed.len());
            if decompressed == input {
                println!("Content matches!");
            }
        }
        Err(e) => println!("FAILED: {:?}", e),
    }
}