#![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::missing_safety_doc)] #![allow(clippy::too_many_arguments)] //! Context-free compression-parameter selection and sizing leaves. //! //! This module deliberately does **not** own the public `ZSTD_*` symbols yet. //! `zstd_compress.c` still owns configuration-sensitive policy: excluded block //! compressors, private `ZSTD_CCtx_params` layouts, LDM workspace sizing, and //! ASAN workspace policy. The C integration layer can select a raw table //! entry here, apply its configured strategy cascade, then use the adjustment //! and sizing leaves below. That keeps the Rust implementation independent of //! C preprocessor state while retaining byte-for-byte C policy for reduced //! builds. use crate::errors::{ZstdErrorCode, ERROR}; use std::mem::size_of; use std::os::raw::c_int; pub const ZSTD_CONTENTSIZE_UNKNOWN: u64 = u64::MAX; const ZSTD_CLEVEL_DEFAULT: c_int = 3; const ZSTD_MAX_CLEVEL: c_int = 22; const ZSTD_TARGETLENGTH_MAX: c_int = 1 << 17; const ZSTD_BLOCKSIZE_MAX: usize = 1 << 17; const ZSTD_WINDOWLOG_MIN: c_int = 10; #[cfg(target_pointer_width = "32")] const ZSTD_WINDOWLOG_MAX: c_int = 30; #[cfg(not(target_pointer_width = "32"))] const ZSTD_WINDOWLOG_MAX: c_int = 31; const ZSTD_HASHLOG_MIN: c_int = 6; const ZSTD_HASHLOG_MAX: c_int = 30; const ZSTD_CHAINLOG_MIN: c_int = ZSTD_HASHLOG_MIN; #[cfg(target_pointer_width = "32")] const ZSTD_CHAINLOG_MAX: c_int = 29; #[cfg(not(target_pointer_width = "32"))] const ZSTD_CHAINLOG_MAX: c_int = 30; const ZSTD_SEARCHLOG_MIN: c_int = 1; const ZSTD_SEARCHLOG_MAX: c_int = ZSTD_WINDOWLOG_MAX - 1; const ZSTD_MINMATCH_MIN: c_int = 3; const ZSTD_MINMATCH_MAX: c_int = 7; const ZSTD_TARGETLENGTH_MIN: c_int = 0; const ZSTD_FAST: c_int = 1; const ZSTD_DFAST: c_int = 2; const ZSTD_GREEDY: c_int = 3; const ZSTD_LAZY: c_int = 4; const ZSTD_LAZY2: c_int = 5; const ZSTD_BTLAZY2: c_int = 6; const ZSTD_BTOPT: c_int = 7; const ZSTD_BTULTRA: c_int = 8; const ZSTD_BTULTRA2: c_int = 9; const ZSTD_C_COMPRESSION_LEVEL: c_int = 100; const ZSTD_C_WINDOW_LOG: c_int = 101; const ZSTD_C_HASH_LOG: c_int = 102; const ZSTD_C_CHAIN_LOG: c_int = 103; const ZSTD_C_SEARCH_LOG: c_int = 104; const ZSTD_C_MIN_MATCH: c_int = 105; const ZSTD_C_TARGET_LENGTH: c_int = 106; const ZSTD_C_STRATEGY: c_int = 107; /// Private compression-parameter modes from `zstd_compress_internal.h`. /// /// They are ABI-compatible with `ZSTD_CParamMode_e` and intentionally kept as /// integer constants because that enum remains private C API for now. pub const ZSTD_RUST_CPM_NO_ATTACH_DICT: c_int = 0; pub const ZSTD_RUST_CPM_ATTACH_DICT: c_int = 1; pub const ZSTD_RUST_CPM_CREATE_CDICT: c_int = 2; pub const ZSTD_RUST_CPM_UNKNOWN: c_int = 3; /// `ZSTD_ParamSwitch_e` values used by the adjustment and sizing leaves. pub const ZSTD_RUST_PS_AUTO: c_int = 0; pub const ZSTD_RUST_PS_ENABLE: c_int = 1; pub const ZSTD_RUST_PS_DISABLE: c_int = 2; /// ABI-compatible `ZSTD_compressionParameters` from `zstd.h`. #[repr(C)] #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct ZSTD_compressionParameters { pub windowLog: u32, pub chainLog: u32, pub hashLog: u32, pub searchLog: u32, pub minMatch: u32, pub targetLength: u32, pub strategy: c_int, } /// ABI-compatible `ZSTD_frameParameters` from `zstd.h`. #[repr(C)] #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct ZSTD_frameParameters { pub contentSizeFlag: c_int, pub checksumFlag: c_int, pub noDictIDFlag: c_int, } /// ABI-compatible `ZSTD_parameters` from `zstd.h`. #[repr(C)] #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct ZSTD_parameters { pub cParams: ZSTD_compressionParameters, pub fParams: ZSTD_frameParameters, } /// ABI-compatible `ZSTD_bounds` from `zstd.h`. #[repr(C)] #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct ZSTD_bounds { pub error: usize, pub lowerBound: c_int, pub upperBound: c_int, } /* `clevels.h`, represented as raw fields so the table stays compact and easy * to compare mechanically against its C source. Field order is W, C, H, S, * L, TL, strategy. */ const DEFAULT_CPARAMS: [[[u32; 7]; 23]; 4] = [ [ [19, 12, 13, 1, 6, 1, ZSTD_FAST as u32], [19, 13, 14, 1, 7, 0, ZSTD_FAST as u32], [20, 15, 16, 1, 6, 0, ZSTD_FAST as u32], [21, 16, 17, 1, 5, 0, ZSTD_DFAST as u32], [21, 18, 18, 1, 5, 0, ZSTD_DFAST as u32], [21, 18, 19, 3, 5, 2, ZSTD_GREEDY as u32], [21, 18, 19, 3, 5, 4, ZSTD_LAZY as u32], [21, 19, 20, 4, 5, 8, ZSTD_LAZY as u32], [21, 19, 20, 4, 5, 16, ZSTD_LAZY2 as u32], [22, 20, 21, 4, 5, 16, ZSTD_LAZY2 as u32], [22, 21, 22, 5, 5, 16, ZSTD_LAZY2 as u32], [22, 21, 22, 6, 5, 16, ZSTD_LAZY2 as u32], [22, 22, 23, 6, 5, 32, ZSTD_LAZY2 as u32], [22, 22, 22, 4, 5, 32, ZSTD_BTLAZY2 as u32], [22, 22, 23, 5, 5, 32, ZSTD_BTLAZY2 as u32], [22, 23, 23, 6, 5, 32, ZSTD_BTLAZY2 as u32], [22, 22, 22, 5, 5, 48, ZSTD_BTOPT as u32], [23, 23, 22, 5, 4, 64, ZSTD_BTOPT as u32], [23, 23, 22, 6, 3, 64, ZSTD_BTULTRA as u32], [23, 24, 22, 7, 3, 256, ZSTD_BTULTRA2 as u32], [25, 25, 23, 7, 3, 256, ZSTD_BTULTRA2 as u32], [26, 26, 24, 7, 3, 512, ZSTD_BTULTRA2 as u32], [27, 27, 25, 9, 3, 999, ZSTD_BTULTRA2 as u32], ], [ [18, 12, 13, 1, 5, 1, ZSTD_FAST as u32], [18, 13, 14, 1, 6, 0, ZSTD_FAST as u32], [18, 14, 14, 1, 5, 0, ZSTD_DFAST as u32], [18, 16, 16, 1, 4, 0, ZSTD_DFAST as u32], [18, 16, 17, 3, 5, 2, ZSTD_GREEDY as u32], [18, 17, 18, 5, 5, 2, ZSTD_GREEDY as u32], [18, 18, 19, 3, 5, 4, ZSTD_LAZY as u32], [18, 18, 19, 4, 4, 4, ZSTD_LAZY as u32], [18, 18, 19, 4, 4, 8, ZSTD_LAZY2 as u32], [18, 18, 19, 5, 4, 8, ZSTD_LAZY2 as u32], [18, 18, 19, 6, 4, 8, ZSTD_LAZY2 as u32], [18, 18, 19, 5, 4, 12, ZSTD_BTLAZY2 as u32], [18, 19, 19, 7, 4, 12, ZSTD_BTLAZY2 as u32], [18, 18, 19, 4, 4, 16, ZSTD_BTOPT as u32], [18, 18, 19, 4, 3, 32, ZSTD_BTOPT as u32], [18, 18, 19, 6, 3, 128, ZSTD_BTOPT as u32], [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA as u32], [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA as u32], [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA2 as u32], [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA2 as u32], [18, 19, 19, 10, 3, 512, ZSTD_BTULTRA2 as u32], [18, 19, 19, 12, 3, 512, ZSTD_BTULTRA2 as u32], [18, 19, 19, 13, 3, 999, ZSTD_BTULTRA2 as u32], ], [ [17, 12, 12, 1, 5, 1, ZSTD_FAST as u32], [17, 12, 13, 1, 6, 0, ZSTD_FAST as u32], [17, 13, 15, 1, 5, 0, ZSTD_FAST as u32], [17, 15, 16, 2, 5, 0, ZSTD_DFAST as u32], [17, 17, 17, 2, 4, 0, ZSTD_DFAST as u32], [17, 16, 17, 3, 4, 2, ZSTD_GREEDY as u32], [17, 16, 17, 3, 4, 4, ZSTD_LAZY as u32], [17, 16, 17, 3, 4, 8, ZSTD_LAZY2 as u32], [17, 16, 17, 4, 4, 8, ZSTD_LAZY2 as u32], [17, 16, 17, 5, 4, 8, ZSTD_LAZY2 as u32], [17, 16, 17, 6, 4, 8, ZSTD_LAZY2 as u32], [17, 17, 17, 5, 4, 8, ZSTD_BTLAZY2 as u32], [17, 18, 17, 7, 4, 12, ZSTD_BTLAZY2 as u32], [17, 18, 17, 3, 4, 12, ZSTD_BTOPT as u32], [17, 18, 17, 4, 3, 32, ZSTD_BTOPT as u32], [17, 18, 17, 6, 3, 256, ZSTD_BTOPT as u32], [17, 18, 17, 6, 3, 128, ZSTD_BTULTRA as u32], [17, 18, 17, 8, 3, 256, ZSTD_BTULTRA as u32], [17, 18, 17, 10, 3, 512, ZSTD_BTULTRA as u32], [17, 18, 17, 5, 3, 256, ZSTD_BTULTRA2 as u32], [17, 18, 17, 7, 3, 512, ZSTD_BTULTRA2 as u32], [17, 18, 17, 9, 3, 512, ZSTD_BTULTRA2 as u32], [17, 18, 17, 11, 3, 999, ZSTD_BTULTRA2 as u32], ], [ [14, 12, 13, 1, 5, 1, ZSTD_FAST as u32], [14, 14, 15, 1, 5, 0, ZSTD_FAST as u32], [14, 14, 15, 1, 4, 0, ZSTD_FAST as u32], [14, 14, 15, 2, 4, 0, ZSTD_DFAST as u32], [14, 14, 14, 4, 4, 2, ZSTD_GREEDY as u32], [14, 14, 14, 3, 4, 4, ZSTD_LAZY as u32], [14, 14, 14, 4, 4, 8, ZSTD_LAZY2 as u32], [14, 14, 14, 6, 4, 8, ZSTD_LAZY2 as u32], [14, 14, 14, 8, 4, 8, ZSTD_LAZY2 as u32], [14, 15, 14, 5, 4, 8, ZSTD_BTLAZY2 as u32], [14, 15, 14, 9, 4, 8, ZSTD_BTLAZY2 as u32], [14, 15, 14, 3, 4, 12, ZSTD_BTOPT as u32], [14, 15, 14, 4, 3, 24, ZSTD_BTOPT as u32], [14, 15, 14, 5, 3, 32, ZSTD_BTULTRA as u32], [14, 15, 15, 6, 3, 64, ZSTD_BTULTRA as u32], [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA as u32], [14, 15, 15, 5, 3, 48, ZSTD_BTULTRA2 as u32], [14, 15, 15, 6, 3, 128, ZSTD_BTULTRA2 as u32], [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA2 as u32], [14, 15, 15, 8, 3, 256, ZSTD_BTULTRA2 as u32], [14, 15, 15, 8, 3, 512, ZSTD_BTULTRA2 as u32], [14, 15, 15, 9, 3, 512, ZSTD_BTULTRA2 as u32], [14, 15, 15, 10, 3, 999, ZSTD_BTULTRA2 as u32], ], ]; #[inline] fn cparams_from_row(row: [u32; 7]) -> ZSTD_compressionParameters { ZSTD_compressionParameters { windowLog: row[0], chainLog: row[1], hashLog: row[2], searchLog: row[3], minMatch: row[4], targetLength: row[5], strategy: row[6] as c_int, } } #[inline] fn bounds(param: c_int) -> ZSTD_bounds { let (lowerBound, upperBound) = match param { ZSTD_C_COMPRESSION_LEVEL => (ZSTD_rust_params_minCLevel(), ZSTD_rust_params_maxCLevel()), ZSTD_C_WINDOW_LOG => (ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX), ZSTD_C_HASH_LOG => (ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX), ZSTD_C_CHAIN_LOG => (ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX), ZSTD_C_SEARCH_LOG => (ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX), ZSTD_C_MIN_MATCH => (ZSTD_MINMATCH_MIN, ZSTD_MINMATCH_MAX), ZSTD_C_TARGET_LENGTH => (ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX), ZSTD_C_STRATEGY => (ZSTD_FAST, ZSTD_BTULTRA2), _ => { return ZSTD_bounds { error: ERROR(ZstdErrorCode::ParameterUnsupported), lowerBound: 0, upperBound: 0, } } }; ZSTD_bounds { error: 0, lowerBound, upperBound, } } #[inline] fn within_bounds(param: c_int, value: c_int) -> bool { let bounds = bounds(param); bounds.error == 0 && value >= bounds.lowerBound && value <= bounds.upperBound } #[inline] fn clamp_unsigned(value: u32, param: c_int) -> u32 { let bounds = bounds(param); debug_assert_eq!(bounds.error, 0); let signed = value as c_int; if signed < bounds.lowerBound { bounds.lowerBound as u32 } else if signed > bounds.upperBound { bounds.upperBound as u32 } else { value } } #[inline] fn clamp_cparams(mut cparams: ZSTD_compressionParameters) -> ZSTD_compressionParameters { cparams.windowLog = clamp_unsigned(cparams.windowLog, ZSTD_C_WINDOW_LOG); cparams.chainLog = clamp_unsigned(cparams.chainLog, ZSTD_C_CHAIN_LOG); cparams.hashLog = clamp_unsigned(cparams.hashLog, ZSTD_C_HASH_LOG); cparams.searchLog = clamp_unsigned(cparams.searchLog, ZSTD_C_SEARCH_LOG); cparams.minMatch = clamp_unsigned(cparams.minMatch, ZSTD_C_MIN_MATCH); cparams.targetLength = clamp_unsigned(cparams.targetLength, ZSTD_C_TARGET_LENGTH); let strategy_bounds = bounds(ZSTD_C_STRATEGY); if cparams.strategy < strategy_bounds.lowerBound { cparams.strategy = strategy_bounds.lowerBound; } else if cparams.strategy > strategy_bounds.upperBound { cparams.strategy = strategy_bounds.upperBound; } cparams } #[inline] fn highbit32(value: u32) -> u32 { debug_assert_ne!(value, 0); u32::BITS - 1 - value.leading_zeros() } #[inline] fn cycle_log(hash_log: u32, strategy: c_int) -> u32 { hash_log.wrapping_sub((strategy >= ZSTD_BTLAZY2) as u32) } #[inline] fn strategy_supports_row_match_finder(strategy: c_int) -> bool { (ZSTD_GREEDY..=ZSTD_LAZY2).contains(&strategy) } #[inline] fn row_match_finder_used(strategy: c_int, mode: c_int) -> bool { debug_assert_ne!(mode, ZSTD_RUST_PS_AUTO); strategy_supports_row_match_finder(strategy) && mode == ZSTD_RUST_PS_ENABLE } /// C ABI for `ZSTD_rowMatchFinderSupported()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_rowMatchFinderSupported(strategy: c_int) -> c_int { c_int::from(strategy_supports_row_match_finder(strategy)) } /// C ABI for `ZSTD_rowMatchFinderUsed()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_rowMatchFinderUsed(strategy: c_int, mode: c_int) -> c_int { c_int::from(row_match_finder_used(strategy, mode)) } #[inline] fn resolve_row_match_finder(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int { if mode != ZSTD_RUST_PS_AUTO { return mode; } if strategy_supports_row_match_finder(cparams.strategy) && cparams.windowLog > 14 { ZSTD_RUST_PS_ENABLE } else { ZSTD_RUST_PS_DISABLE } } /// C ABI for `ZSTD_resolveRowMatchFinderMode()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_resolveRowMatchFinderMode( mode: c_int, cparams: ZSTD_compressionParameters, ) -> c_int { resolve_row_match_finder(mode, cparams) } #[inline] fn resolve_block_splitter(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int { if mode != ZSTD_RUST_PS_AUTO { return mode; } if cparams.strategy >= ZSTD_BTOPT && cparams.windowLog >= 17 { ZSTD_RUST_PS_ENABLE } else { ZSTD_RUST_PS_DISABLE } } /// C ABI for `ZSTD_resolveBlockSplitterMode()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_resolveBlockSplitterMode( mode: c_int, cparams: ZSTD_compressionParameters, ) -> c_int { resolve_block_splitter(mode, cparams) } #[inline] fn resolve_enable_ldm(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int { if mode != ZSTD_RUST_PS_AUTO { return mode; } if cparams.strategy >= ZSTD_BTOPT && cparams.windowLog >= 27 { ZSTD_RUST_PS_ENABLE } else { ZSTD_RUST_PS_DISABLE } } /// C ABI for `ZSTD_resolveEnableLdm()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_resolveEnableLdm( mode: c_int, cparams: ZSTD_compressionParameters, ) -> c_int { resolve_enable_ldm(mode, cparams) } #[inline] fn resolve_external_repcode_search(mode: c_int, compression_level: c_int) -> c_int { if mode != ZSTD_RUST_PS_AUTO { return mode; } if compression_level < 10 { ZSTD_RUST_PS_DISABLE } else { ZSTD_RUST_PS_ENABLE } } /// C ABI for `ZSTD_resolveExternalRepcodeSearch()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_resolveExternalRepcodeSearch( mode: c_int, compression_level: c_int, ) -> c_int { resolve_external_repcode_search(mode, compression_level) } #[inline] fn cdict_indices_are_tagged(cparams: ZSTD_compressionParameters) -> bool { cparams.strategy == ZSTD_FAST || cparams.strategy == ZSTD_DFAST } /// C ABI for `ZSTD_CDictIndicesAreTagged()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_cdictIndicesAreTagged( cparams: ZSTD_compressionParameters, ) -> c_int { c_int::from(cdict_indices_are_tagged(cparams)) } #[inline] fn dict_and_window_log(window_log: u32, src_size: u64, dict_size: u64) -> u32 { /* 1ULL << ZSTD_WINDOWLOG_MAX, which is smaller for 32-bit builds. */ const MAX_WINDOW_SIZE: u64 = 1u64 << ZSTD_WINDOWLOG_MAX; if dict_size == 0 { return window_log; } debug_assert!(window_log <= ZSTD_WINDOWLOG_MAX as u32); debug_assert_ne!(src_size, ZSTD_CONTENTSIZE_UNKNOWN); let window_size = 1u64 << window_log; if window_size >= dict_size.wrapping_add(src_size) { window_log } else { let dict_and_window_size = dict_size.wrapping_add(window_size); if dict_and_window_size >= MAX_WINDOW_SIZE { ZSTD_WINDOWLOG_MAX as u32 } else { highbit32((dict_and_window_size as u32).wrapping_sub(1)) + 1 } } } /// Adjusts a *validated, configuration-resolved* parameter set. /// /// This is the direct Rust leaf for `ZSTD_adjustCParams_internal()` after the /// C wrapper has applied its `ZSTD_EXCLUDE_*_BLOCK_COMPRESSOR` cascade. In /// particular, it does not select a fallback strategy itself. `srcSize == 0` /// means a known empty input here, just as it does in the C internal helper; /// the public C wrapper must translate zero to `ZSTD_CONTENTSIZE_UNKNOWN`. fn adjust_cparams( mut cparams: ZSTD_compressionParameters, mut src_size: u64, mut dict_size: usize, mode: c_int, mut use_row_match_finder: c_int, ) -> ZSTD_compressionParameters { debug_assert_eq!(check_cparams(cparams), 0); const MIN_SRC_SIZE: u64 = 513; /* 1ULL << (ZSTD_WINDOWLOG_MAX - 1), which is smaller for 32-bit builds. */ const MAX_WINDOW_RESIZE: u64 = 1u64 << (ZSTD_WINDOWLOG_MAX - 1); match mode { ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT => {} ZSTD_RUST_CPM_CREATE_CDICT => { if dict_size != 0 && src_size == ZSTD_CONTENTSIZE_UNKNOWN { src_size = MIN_SRC_SIZE; } } ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0, _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"), } if src_size <= MAX_WINDOW_RESIZE && (dict_size as u64) <= MAX_WINDOW_RESIZE { let total_size = src_size.wrapping_add(dict_size as u64) as u32; let hash_size_min = 1u32 << ZSTD_HASHLOG_MIN; let src_log = if total_size < hash_size_min { ZSTD_HASHLOG_MIN as u32 } else { highbit32(total_size.wrapping_sub(1)) + 1 }; cparams.windowLog = cparams.windowLog.min(src_log); } if src_size != ZSTD_CONTENTSIZE_UNKNOWN { let dict_and_window_log = dict_and_window_log(cparams.windowLog, src_size, dict_size as u64); let cycle_log = cycle_log(cparams.chainLog, cparams.strategy); cparams.hashLog = cparams.hashLog.min(dict_and_window_log + 1); if cycle_log > dict_and_window_log { cparams.chainLog = cparams .chainLog .wrapping_sub(cycle_log - dict_and_window_log); } } cparams.windowLog = cparams.windowLog.max(ZSTD_WINDOWLOG_MIN as u32); /* The short-cache tags used for fast and dfast CDicts consume eight bits * of each 32-bit index. This is a fixed private-header constant today; * if it becomes configurable, the C shim must pass it as an explicit * adjustment input rather than silently changing this leaf. */ if mode == ZSTD_RUST_CPM_CREATE_CDICT && (cparams.strategy == ZSTD_FAST || cparams.strategy == ZSTD_DFAST) { const SHORT_CACHE_TAG_BITS: u32 = 8; let max_short_cache_hash_log = 32 - SHORT_CACHE_TAG_BITS; cparams.hashLog = cparams.hashLog.min(max_short_cache_hash_log); cparams.chainLog = cparams.chainLog.min(max_short_cache_hash_log); } if use_row_match_finder == ZSTD_RUST_PS_AUTO { use_row_match_finder = ZSTD_RUST_PS_ENABLE; } if row_match_finder_used(cparams.strategy, use_row_match_finder) { const ROW_HASH_TAG_BITS: u32 = 8; let row_log = cparams.searchLog.clamp(4, 6); let max_hash_log = (32 - ROW_HASH_TAG_BITS) + row_log; debug_assert!(cparams.hashLog >= row_log); cparams.hashLog = cparams.hashLog.min(max_hash_log); } cparams } #[inline] fn get_cparam_row_size(src_size_hint: u64, dict_size: usize, mode: c_int) -> u64 { let mut dict_size = dict_size as u64; match mode { ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT | ZSTD_RUST_CPM_CREATE_CDICT => {} ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0, _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"), } let unknown = src_size_hint == ZSTD_CONTENTSIZE_UNKNOWN; let added_size = if unknown && dict_size > 0 { 500 } else { 0 }; if unknown && dict_size == 0 { ZSTD_CONTENTSIZE_UNKNOWN } else { src_size_hint .wrapping_add(dict_size) .wrapping_add(added_size) } } /// Selects a raw compression-level-table entry, without strategy cascading or /// source/dictionary adjustment. /// /// A C wrapper must apply its active excluded-compressor cascade to the /// returned strategy before calling [`ZSTD_rust_params_adjustCParams`]. fn select_cparams( compression_level: c_int, src_size_hint: u64, dict_size: usize, mode: c_int, ) -> ZSTD_compressionParameters { let row_size = get_cparam_row_size(src_size_hint, dict_size, mode); let table_id = usize::from(row_size <= 256 * 1024) + usize::from(row_size <= 128 * 1024) + usize::from(row_size <= 16 * 1024); let row = if compression_level == 0 { ZSTD_CLEVEL_DEFAULT } else if compression_level < 0 { 0 } else { compression_level.min(ZSTD_MAX_CLEVEL) } as usize; let mut cparams = cparams_from_row(DEFAULT_CPARAMS[table_id][row]); if compression_level < 0 { let clamped = compression_level.max(ZSTD_rust_params_minCLevel()); cparams.targetLength = (-clamped) as u32; } cparams } #[inline] fn make_params(cparams: ZSTD_compressionParameters) -> ZSTD_parameters { ZSTD_parameters { cParams: cparams, fParams: ZSTD_frameParameters { contentSizeFlag: 1, checksumFlag: 0, noDictIDFlag: 0, }, } } #[inline] fn check_cparams(cparams: ZSTD_compressionParameters) -> usize { if !within_bounds(ZSTD_C_WINDOW_LOG, cparams.windowLog as c_int) || !within_bounds(ZSTD_C_CHAIN_LOG, cparams.chainLog as c_int) || !within_bounds(ZSTD_C_HASH_LOG, cparams.hashLog as c_int) || !within_bounds(ZSTD_C_SEARCH_LOG, cparams.searchLog as c_int) || !within_bounds(ZSTD_C_MIN_MATCH, cparams.minMatch as c_int) || !within_bounds(ZSTD_C_TARGET_LENGTH, cparams.targetLength as c_int) || !within_bounds(ZSTD_C_STRATEGY, cparams.strategy) { ERROR(ZstdErrorCode::ParameterOutOfBound) } else { 0 } } /// Returns the highest table-backed compression level (`ZSTD_MAX_CLEVEL`). #[no_mangle] pub extern "C" fn ZSTD_rust_params_maxCLevel() -> c_int { ZSTD_MAX_CLEVEL } /// Returns the lowest public fast level (`-ZSTD_TARGETLENGTH_MAX`). #[no_mangle] pub extern "C" fn ZSTD_rust_params_minCLevel() -> c_int { -ZSTD_TARGETLENGTH_MAX } /// Returns the default compression level from `zstd.h`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_defaultCLevel() -> c_int { ZSTD_CLEVEL_DEFAULT } /// Returns bounds for the seven core compression parameters and compression /// level. Other `ZSTD_cParameter` cases remain C-owned. #[no_mangle] pub extern "C" fn ZSTD_rust_params_getBounds(param: c_int) -> ZSTD_bounds { bounds(param) } /// Checks the seven fields of `ZSTD_compressionParameters`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_checkCParams(cparams: ZSTD_compressionParameters) -> usize { check_cparams(cparams) } /// Clamps the seven fields of `ZSTD_compressionParameters` to public bounds. #[no_mangle] pub extern "C" fn ZSTD_rust_params_clampCParams( cparams: ZSTD_compressionParameters, ) -> ZSTD_compressionParameters { clamp_cparams(cparams) } /// C ABI for `ZSTD_cycleLog()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_cycleLog(hashLog: u32, strategy: c_int) -> u32 { cycle_log(hashLog, strategy) } /// C ABI for private `ZSTD_getCParamRowSize()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_getCParamRowSize( srcSizeHint: u64, dictSize: usize, mode: c_int, ) -> u64 { get_cparam_row_size(srcSizeHint, dictSize, mode) } /// Returns the unadjusted compression-level-table entry. #[no_mangle] pub extern "C" fn ZSTD_rust_params_selectCParams( compressionLevel: c_int, srcSizeHint: u64, dictSize: usize, mode: c_int, ) -> ZSTD_compressionParameters { select_cparams(compressionLevel, srcSizeHint, dictSize, mode) } /// Adjusts a validated, strategy-resolved C parameter set. /// /// See [`adjust_cparams`] for the required C-side policy step. #[no_mangle] pub extern "C" fn ZSTD_rust_params_adjustCParams( cparams: ZSTD_compressionParameters, srcSize: u64, dictSize: usize, mode: c_int, useRowMatchFinder: c_int, ) -> ZSTD_compressionParameters { adjust_cparams(cparams, srcSize, dictSize, mode, useRowMatchFinder) } /// Builds `ZSTD_parameters` with the public default frame parameters. #[no_mangle] pub extern "C" fn ZSTD_rust_params_makeParams( cparams: ZSTD_compressionParameters, ) -> ZSTD_parameters { make_params(cparams) } /// Runtime sizes needed to reproduce `ZSTD_sizeof_matchState()` without /// exposing private C structures to Rust. /// /// `asanRedzoneSize` is `ZSTD_CWKSP_ASAN_REDZONE_SIZE` when workspace /// poisoning is enabled and zero otherwise. `matchTSize` and `optimalTSize` /// must be `sizeof(ZSTD_match_t)` and `sizeof(ZSTD_optimal_t)` respectively. #[repr(C)] #[derive(Clone, Copy, Debug, Default)] pub struct ZSTD_rustMatchStateSizing { pub hashLog3Max: u32, pub matchTSize: usize, pub optimalTSize: usize, pub asanRedzoneSize: usize, } /// C-only layout inputs for `ZSTD_estimateCDictSize_advanced()`. #[repr(C)] #[derive(Clone, Copy, Debug, Default)] pub struct ZSTD_rustCDictSizing { pub cdictSize: usize, pub hufWorkspaceSize: usize, pub hashLog3Max: u32, pub matchTSize: usize, pub optimalTSize: usize, pub asanRedzoneSize: usize, } #[inline] fn cwksp_alloc_size(size: usize, asan_redzone_size: usize) -> usize { if size == 0 { 0 } else { size.wrapping_add(asan_redzone_size.wrapping_mul(2)) } } #[inline] fn cwksp_align(size: usize, alignment: usize) -> usize { debug_assert!(alignment.is_power_of_two()); size.wrapping_add(alignment - 1) & !(alignment - 1) } #[inline] fn cwksp_aligned64_alloc_size(size: usize, asan_redzone_size: usize) -> usize { cwksp_alloc_size(cwksp_align(size, 64), asan_redzone_size) } #[inline] fn shift_size(log: u32) -> usize { debug_assert!(log < usize::BITS); 1usize << log } #[inline] fn allocate_chain_table(strategy: c_int, use_row_match_finder: c_int, for_dds_dict: bool) -> bool { for_dds_dict || (strategy != ZSTD_FAST && !row_match_finder_used(strategy, use_row_match_finder)) } /// C ABI for `ZSTD_allocateChainTable()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_allocateChainTable( strategy: c_int, mode: c_int, for_dds_dict: c_int, ) -> c_int { c_int::from(allocate_chain_table(strategy, mode, for_dds_dict != 0)) } fn estimate_match_state_size( cparams: ZSTD_compressionParameters, use_row_match_finder: c_int, enable_dedicated_dict_search: bool, for_cctx: bool, sizing: ZSTD_rustMatchStateSizing, ) -> usize { if check_cparams(cparams) != 0 || use_row_match_finder == ZSTD_RUST_PS_AUTO { return 0; } let chain_size = if allocate_chain_table( cparams.strategy, use_row_match_finder, enable_dedicated_dict_search && !for_cctx, ) { shift_size(cparams.chainLog) } else { 0 }; let hash_size = shift_size(cparams.hashLog); let hash_log_3 = if for_cctx && cparams.minMatch == 3 { cparams.windowLog.min(sizing.hashLog3Max) } else { 0 }; let hash3_size = if hash_log_3 == 0 { 0 } else { shift_size(hash_log_3) }; let table_space = chain_size .wrapping_mul(size_of::()) .wrapping_add(hash_size.wrapping_mul(size_of::())) .wrapping_add(hash3_size.wrapping_mul(size_of::())); let redzone = sizing.asanRedzoneSize; let opt_potential_space = cwksp_aligned64_alloc_size((52 + 1) * size_of::(), redzone) .wrapping_add(cwksp_aligned64_alloc_size( (35 + 1) * size_of::(), redzone, )) .wrapping_add(cwksp_aligned64_alloc_size( (31 + 1) * size_of::(), redzone, )) .wrapping_add(cwksp_aligned64_alloc_size( (1 << 8) * size_of::(), redzone, )) .wrapping_add(cwksp_aligned64_alloc_size( 4099usize.wrapping_mul(sizing.matchTSize), redzone, )) .wrapping_add(cwksp_aligned64_alloc_size( 4099usize.wrapping_mul(sizing.optimalTSize), redzone, )); let lazy_additional_space = if row_match_finder_used(cparams.strategy, use_row_match_finder) { cwksp_aligned64_alloc_size(hash_size, redzone) } else { 0 }; let opt_space = if for_cctx && cparams.strategy >= ZSTD_BTOPT { opt_potential_space } else { 0 }; let slack_space = 2 * 64; table_space .wrapping_add(opt_space) .wrapping_add(slack_space) .wrapping_add(lazy_additional_space) } /// Pure leaf for private `ZSTD_sizeof_matchState()`. /// /// `useRowMatchFinder` must already be resolved to enable or disable. A NULL /// `sizing` pointer or invalid C parameters returns zero; C never supplies /// either in a valid estimator call. #[no_mangle] pub unsafe extern "C" fn ZSTD_rust_params_estimateMatchStateSize( cparams: ZSTD_compressionParameters, useRowMatchFinder: c_int, enableDedicatedDictSearch: c_int, forCCtx: u32, sizing: *const ZSTD_rustMatchStateSizing, ) -> usize { if sizing.is_null() { return 0; } let sizing = unsafe { *sizing }; estimate_match_state_size( cparams, useRowMatchFinder, enableDedicatedDictSearch != 0, forCCtx != 0, sizing, ) } #[inline] fn max_nb_seq(block_size: usize, min_match: u32, use_sequence_producer: bool) -> usize { let divider = if min_match == 3 || use_sequence_producer { 3 } else { 4 }; block_size / divider } /// Pure leaf for private `ZSTD_maxNbSeq()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_maxNbSeq( blockSize: usize, minMatch: u32, useSequenceProducer: c_int, ) -> usize { max_nb_seq(blockSize, minMatch, useSequenceProducer != 0) } /// Pure leaf for private `ZSTD_resolveMaxBlockSize()`. #[no_mangle] pub extern "C" fn ZSTD_rust_params_resolveMaxBlockSize(maxBlockSize: usize) -> usize { if maxBlockSize == 0 { ZSTD_BLOCKSIZE_MAX } else { maxBlockSize } } fn estimate_cdict_size_from_cparams( dict_size: usize, cparams: ZSTD_compressionParameters, dict_load_method: c_int, sizing: ZSTD_rustCDictSizing, ) -> usize { if check_cparams(cparams) != 0 { return 0; } let match_state_sizing = ZSTD_rustMatchStateSizing { hashLog3Max: sizing.hashLog3Max, matchTSize: sizing.matchTSize, optimalTSize: sizing.optimalTSize, asanRedzoneSize: sizing.asanRedzoneSize, }; let row_match_finder = resolve_row_match_finder(ZSTD_RUST_PS_AUTO, cparams); let copied_dict_space = if dict_load_method == 1 { 0 } else { cwksp_alloc_size( cwksp_align(dict_size, size_of::()), sizing.asanRedzoneSize, ) }; cwksp_alloc_size(sizing.cdictSize, sizing.asanRedzoneSize) .wrapping_add(cwksp_alloc_size( sizing.hufWorkspaceSize, sizing.asanRedzoneSize, )) .wrapping_add(estimate_match_state_size( cparams, row_match_finder, true, false, match_state_sizing, )) .wrapping_add(copied_dict_space) } /// Parameter-only leaf for `ZSTD_estimateCDictSize_advanced()`. /// /// C retains ownership of `sizeof(ZSTD_CDict)`, HUF workspace configuration, /// and sanitizer workspace policy, then passes them in `sizing`. A NULL sizing /// pointer returns zero. #[no_mangle] pub unsafe extern "C" fn ZSTD_rust_params_estimateCDictSizeFromCParams( dictSize: usize, cparams: ZSTD_compressionParameters, dictLoadMethod: c_int, sizing: *const ZSTD_rustCDictSizing, ) -> usize { if sizing.is_null() { return 0; } estimate_cdict_size_from_cparams(dictSize, cparams, dictLoadMethod, unsafe { *sizing }) } #[cfg(test)] mod tests { use super::*; use crate::errors::ERR_isError; use std::mem::{align_of, size_of}; fn adjust_public( cparams: ZSTD_compressionParameters, src_size: u64, dict_size: usize, ) -> ZSTD_compressionParameters { let src_size = if src_size == 0 { ZSTD_CONTENTSIZE_UNKNOWN } else { src_size }; adjust_cparams( clamp_cparams(cparams), src_size, dict_size, ZSTD_RUST_CPM_UNKNOWN, ZSTD_RUST_PS_AUTO, ) } #[test] fn abi_parameter_layouts_match_zstd_h() { assert_eq!( size_of::(), 7 * size_of::() ); assert_eq!(align_of::(), align_of::()); assert_eq!(size_of::(), 3 * size_of::()); assert_eq!(size_of::(), 10 * size_of::()); assert_eq!( size_of::(), size_of::() + 2 * size_of::() ); } fn policy_cparams(strategy: c_int, window_log: u32) -> ZSTD_compressionParameters { ZSTD_compressionParameters { windowLog: window_log, strategy, ..ZSTD_compressionParameters::default() } } #[test] fn row_match_finder_policy_preserves_strategy_and_window_boundaries() { assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_FAST), 0); assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_GREEDY), 1); assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_LAZY2), 1); assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_BTLAZY2), 0); assert_eq!( ZSTD_rust_params_rowMatchFinderUsed(ZSTD_GREEDY, ZSTD_RUST_PS_ENABLE), 1 ); assert_eq!( ZSTD_rust_params_rowMatchFinderUsed(ZSTD_GREEDY, ZSTD_RUST_PS_DISABLE), 0 ); assert_eq!( ZSTD_rust_params_rowMatchFinderUsed(ZSTD_FAST, ZSTD_RUST_PS_ENABLE), 0 ); assert_eq!( ZSTD_rust_params_resolveRowMatchFinderMode( ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_GREEDY, 14), ), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveRowMatchFinderMode( ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_GREEDY, 15), ), ZSTD_RUST_PS_ENABLE ); assert_eq!( ZSTD_rust_params_resolveRowMatchFinderMode( ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTLAZY2, 31), ), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveRowMatchFinderMode( ZSTD_RUST_PS_ENABLE, policy_cparams(ZSTD_FAST, 14), ), ZSTD_RUST_PS_ENABLE ); } #[test] fn block_splitter_and_ldm_policy_match_window_boundaries() { assert_eq!( ZSTD_rust_params_resolveBlockSplitterMode( ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTOPT, 16), ), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveBlockSplitterMode( ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTOPT, 17), ), ZSTD_RUST_PS_ENABLE ); assert_eq!( ZSTD_rust_params_resolveBlockSplitterMode( ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTLAZY2, 31), ), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveBlockSplitterMode( ZSTD_RUST_PS_ENABLE, policy_cparams(ZSTD_FAST, 1), ), ZSTD_RUST_PS_ENABLE ); assert_eq!( ZSTD_rust_params_resolveEnableLdm(ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTOPT, 26),), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveEnableLdm(ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTOPT, 27),), ZSTD_RUST_PS_ENABLE ); assert_eq!( ZSTD_rust_params_resolveEnableLdm(ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTLAZY2, 31),), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveEnableLdm( ZSTD_RUST_PS_DISABLE, policy_cparams(ZSTD_BTULTRA2, 31), ), ZSTD_RUST_PS_DISABLE ); } #[test] fn chain_table_policy_matches_dds_and_row_match_finder_modes() { assert_eq!( ZSTD_rust_params_allocateChainTable(ZSTD_FAST, ZSTD_RUST_PS_DISABLE, 0), 0 ); assert_eq!( ZSTD_rust_params_allocateChainTable(ZSTD_DFAST, ZSTD_RUST_PS_DISABLE, 0), 1 ); assert_eq!( ZSTD_rust_params_allocateChainTable(ZSTD_GREEDY, ZSTD_RUST_PS_ENABLE, 0), 0 ); assert_eq!( ZSTD_rust_params_allocateChainTable(ZSTD_FAST, ZSTD_RUST_PS_DISABLE, 1), 1 ); } #[test] fn external_repcode_and_cdict_tagging_match_boundaries() { assert_eq!( ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_AUTO, 9), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_AUTO, 10), ZSTD_RUST_PS_ENABLE ); assert_eq!( ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_DISABLE, 100), ZSTD_RUST_PS_DISABLE ); assert_eq!( ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_ENABLE, -100), ZSTD_RUST_PS_ENABLE ); assert_eq!( ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_FAST, 1)), 1 ); assert_eq!( ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_DFAST, 1)), 1 ); assert_eq!( ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_GREEDY, 1)), 0 ); assert_eq!( ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_BTULTRA2, 1)), 0 ); } #[test] fn level_tables_match_representative_clevels_entries() { let large = select_cparams(3, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN); assert_eq!( large, ZSTD_compressionParameters { windowLog: 21, chainLog: 16, hashLog: 17, searchLog: 1, minMatch: 5, targetLength: 0, strategy: ZSTD_DFAST, } ); let small = select_cparams(3, 16 * 1024, 0, ZSTD_RUST_CPM_UNKNOWN); assert_eq!( small, ZSTD_compressionParameters { windowLog: 14, chainLog: 14, hashLog: 15, searchLog: 2, minMatch: 4, targetLength: 0, strategy: ZSTD_DFAST, } ); let fast = select_cparams(-5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN); assert_eq!(fast.strategy, ZSTD_FAST); assert_eq!(fast.targetLength, 5); assert_eq!( select_cparams(999, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN), select_cparams(22, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN) ); } #[test] fn adjustment_clamps_and_downsizes_like_the_c_leaf() { let input = ZSTD_compressionParameters { windowLog: 31, chainLog: 30, hashLog: 30, searchLog: 1, minMatch: 3, targetLength: 0, strategy: ZSTD_BTOPT, }; let adjusted = adjust_public(input, 1, 0); assert_eq!(adjusted.windowLog, 10); /* C applies WINDOWLOG_ABSOLUTEMIN only after it has used the smaller * temporary window to downsize the hash and chain logs. */ assert_eq!(adjusted.hashLog, 7); assert_eq!(adjusted.chainLog, 7); assert_eq!(ZSTD_rust_params_checkCParams(adjusted), 0); let clamped = ZSTD_rust_params_clampCParams(ZSTD_compressionParameters { windowLog: u32::MAX, chainLog: 0, hashLog: 0, searchLog: 0, minMatch: 0, targetLength: u32::MAX, strategy: 99, }); assert_eq!(clamped.windowLog, ZSTD_WINDOWLOG_MIN as u32); assert_eq!(clamped.chainLog, ZSTD_CHAINLOG_MIN as u32); assert_eq!(clamped.hashLog, ZSTD_HASHLOG_MIN as u32); assert_eq!(clamped.searchLog, ZSTD_SEARCHLOG_MIN as u32); assert_eq!(clamped.minMatch, ZSTD_MINMATCH_MIN as u32); assert_eq!(clamped.targetLength, ZSTD_TARGETLENGTH_MIN as u32); assert_eq!(clamped.strategy, ZSTD_BTULTRA2); } #[test] fn checking_and_bounds_preserve_the_public_error_contract() { let valid = select_cparams(1, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN); assert_eq!(check_cparams(valid), 0); let mut invalid = valid; invalid.minMatch = 2; assert!(ERR_isError(check_cparams(invalid))); let bounds = ZSTD_rust_params_getBounds(ZSTD_C_HASH_LOG); assert_eq!(bounds.error, 0); assert_eq!(bounds.lowerBound, 6); assert_eq!(bounds.upperBound, 30); assert!(ERR_isError(ZSTD_rust_params_getBounds(-1).error)); } #[test] fn params_default_frame_flags_match_c() { let cparams = select_cparams(5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN); let params = ZSTD_rust_params_makeParams(cparams); assert_eq!(params.cParams, cparams); assert_eq!(params.fParams.contentSizeFlag, 1); assert_eq!(params.fParams.checksumFlag, 0); assert_eq!(params.fParams.noDictIDFlag, 0); } #[test] fn row_size_preserves_unknown_dictionary_overflow_semantics() { assert_eq!( get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN), ZSTD_CONTENTSIZE_UNKNOWN ); assert_eq!( get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 1, ZSTD_RUST_CPM_UNKNOWN), 500 ); assert_eq!( get_cparam_row_size(128 * 1024, 1, ZSTD_RUST_CPM_ATTACH_DICT), 128 * 1024 ); } #[test] fn match_state_sizing_reproduces_table_and_row_rules() { let sizing = ZSTD_rustMatchStateSizing { hashLog3Max: 17, matchTSize: 16, optimalTSize: 32, asanRedzoneSize: 0, }; let fast = ZSTD_compressionParameters { windowLog: 10, chainLog: 10, hashLog: 10, searchLog: 1, minMatch: 4, targetLength: 0, strategy: ZSTD_FAST, }; assert_eq!( estimate_match_state_size(fast, ZSTD_RUST_PS_DISABLE, false, true, sizing), 4096 + 128 ); let row = ZSTD_compressionParameters { windowLog: 15, chainLog: 10, hashLog: 10, searchLog: 4, minMatch: 4, targetLength: 0, strategy: ZSTD_GREEDY, }; assert_eq!( estimate_match_state_size(row, ZSTD_RUST_PS_ENABLE, false, true, sizing), 4096 + 1024 + 128 ); assert_eq!(ZSTD_rust_params_maxNbSeq(100, 3, 0), 33); assert_eq!(ZSTD_rust_params_maxNbSeq(100, 4, 0), 25); assert_eq!(ZSTD_rust_params_resolveMaxBlockSize(0), 128 * 1024); } }