zstd-complete 0.3.0

A pure Rust Zstandard compressor and decompressor with bounded streaming I/O
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
115
116
117
118
119
120
121
122
123

//! Optimal frame strategy and no-dictionary block dispatch.

use crate::encoding::{
    blocks::BlockCompressionConfig,
    levels::c_port::{
        block_policy::BlockEncodingPolicy,
        frame_state::BlockEncodeMode,
        greedy_block::{GreedyBlockEncodeContext, GreedyBlockSource, GreedyEncodedBlock},
        ldm::opt::LdmOptCursor,
        opt_encode::{
            encode_block_btopt_no_dict_with_state_and_policy,
            encode_block_btultra_no_dict_with_state_and_policy,
            encode_block_opt_no_dict_with_state_and_policy_and_ldm_in_mode,
        },
        opt_state::{OptBlockState, OptParserStrategy},
        params::{CompressionParameters, Strategy},
        sequence_store::RepeatOffsets,
    },
};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum OptFrameStrategy {
    BtOpt,
    BtUltra,
    BtUltra2,
}

pub(super) fn selected_opt_frame_strategy(strategy: Strategy) -> OptFrameStrategy {
    match strategy {
        Strategy::BtOpt => OptFrameStrategy::BtOpt,
        Strategy::BtUltra => OptFrameStrategy::BtUltra,
        Strategy::BtUltra2 => OptFrameStrategy::BtUltra2,
        _ => unreachable!("only optimal strategies route through opt_frame"),
    }
}

pub(super) fn opt_parser_strategy(strategy: OptFrameStrategy) -> OptParserStrategy {
    match strategy {
        OptFrameStrategy::BtOpt => OptParserStrategy::BtOpt,
        OptFrameStrategy::BtUltra | OptFrameStrategy::BtUltra2 => OptParserStrategy::BtUltra,
    }
}

#[allow(clippy::too_many_arguments)]
pub(super) fn encode_block_opt_no_dict_with_state(
    source: GreedyBlockSource<'_>,
    last_block: bool,
    params: CompressionParameters,
    config: BlockCompressionConfig,
    repeat_offsets: RepeatOffsets,
    opt_state: &mut OptBlockState,
    context: GreedyBlockEncodeContext<'_, '_>,
    strategy: OptFrameStrategy,
    block_encode_mode: BlockEncodeMode,
    policy: BlockEncodingPolicy,
    ldm_cursor: Option<&mut LdmOptCursor<'_>>,
) -> Result<GreedyEncodedBlock, crate::workspace::CapacityError> {
    let target_mode = block_encode_mode.target_c_block_size().is_some();
    match strategy {
        OptFrameStrategy::BtOpt => {
            if ldm_cursor.is_some() || target_mode {
                encode_block_opt_no_dict_with_state_and_policy_and_ldm_in_mode(
                    source,
                    last_block,
                    params,
                    config,
                    repeat_offsets,
                    opt_state,
                    context,
                    OptParserStrategy::BtOpt,
                    block_encode_mode,
                    policy,
                    ldm_cursor,
                )
            } else {
                encode_block_btopt_no_dict_with_state_and_policy(
                    source,
                    last_block,
                    params,
                    config,
                    repeat_offsets,
                    opt_state,
                    context,
                    block_encode_mode.split_block_enabled(),
                    policy,
                )
            }
        }
        OptFrameStrategy::BtUltra | OptFrameStrategy::BtUltra2 => {
            debug_assert!(matches!(
                params.strategy,
                Strategy::BtUltra | Strategy::BtUltra2
            ));
            if strategy == OptFrameStrategy::BtUltra2 || ldm_cursor.is_some() || target_mode {
                encode_block_opt_no_dict_with_state_and_policy_and_ldm_in_mode(
                    source,
                    last_block,
                    params,
                    config,
                    repeat_offsets,
                    opt_state,
                    context,
                    OptParserStrategy::BtUltra,
                    block_encode_mode,
                    policy,
                    ldm_cursor,
                )
            } else {
                encode_block_btultra_no_dict_with_state_and_policy(
                    source,
                    last_block,
                    params,
                    config,
                    repeat_offsets,
                    opt_state,
                    context,
                    block_encode_mode.split_block_enabled(),
                    policy,
                )
            }
        }
    }
}