1use libc::size_t;
2
3use crate::lib::common::xxhash::XXH64_state_t;
4
5use crate::lib::common::zstd_trace::ZSTD_TraceCtx;
6use crate::lib::decompress::huf_decompress::DTable;
7use crate::lib::decompress::zstd_ddict::{MultipleDDicts, ZSTD_DDict, ZSTD_DDictHashSet};
8use crate::lib::decompress::zstd_decompress_block::FseWorkspace;
9use crate::lib::zstd::{BufferMode, Format, ZSTD_customMem, ZSTD_outBuffer};
10
11pub mod huf_decompress;
12pub mod zstd_ddict;
13pub mod zstd_decompress;
14pub mod zstd_decompress_block;
15
16static LL_base: [u32; 36] = [
17 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 24, 28, 32, 40, 48, 64,
18 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000,
19];
20static OF_base: [u32; 32] = [
21 0, 1, 1, 5, 0xd, 0x1d, 0x3d, 0x7d, 0xfd, 0x1fd, 0x3fd, 0x7fd, 0xffd, 0x1ffd, 0x3ffd, 0x7ffd,
22 0xfffd, 0x1fffd, 0x3fffd, 0x7fffd, 0xffffd, 0x1ffffd, 0x3ffffd, 0x7ffffd, 0xfffffd, 0x1fffffd,
23 0x3fffffd, 0x7fffffd, 0xffffffd, 0x1ffffffd, 0x3ffffffd, 0x7ffffffd,
24];
25static OF_bits: [u8; 32] = [
26 0, 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,
27 26, 27, 28, 29, 30, 31,
28];
29static ML_base: [u32; 53] = [
30 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,
31 28, 29, 30, 31, 32, 33, 34, 35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203,
32 0x403, 0x803, 0x1003, 0x2003, 0x4003, 0x8003, 0x10003,
33];
34
35#[derive(Copy, Clone)]
36#[repr(C)]
37pub struct ZSTD_seqSymbol_header {
38 pub fastMode: u32,
39 pub tableLog: u32,
40}
41
42#[derive(Copy, Clone)]
43#[repr(C)]
44pub struct ZSTD_seqSymbol {
45 pub nextState: u16,
46 pub nbAdditionalBits: u8,
47 pub nbBits: u8,
48 pub baseValue: u32,
49}
50
51#[derive(Copy, Clone)]
52#[repr(C)]
53pub struct ZSTD_entropyDTables_t {
54 pub LLTable: SymbolTable<512>,
55 pub OFTable: SymbolTable<256>,
56 pub MLTable: SymbolTable<512>,
57 pub hufTable: DTable,
58 pub rep: [u32; 3],
59 pub workspace: FseWorkspace,
60}
61
62#[derive(Copy, Clone)]
63#[repr(C)]
64pub struct SymbolTable<const N: usize> {
65 header: ZSTD_seqSymbol_header,
66 symbols: [ZSTD_seqSymbol; N],
67}
68
69impl<const N: usize> SymbolTable<N> {
70 fn as_mut_ptr(&mut self) -> *mut ZSTD_seqSymbol {
71 unsafe { core::mem::transmute(self) }
72 }
73
74 fn as_ptr(&self) -> *const ZSTD_seqSymbol {
75 unsafe { core::mem::transmute(self) }
76 }
77}
78
79pub type ZSTD_dStage = core::ffi::c_uint;
80
81#[repr(u32)]
82#[derive(Debug, Clone, Copy, PartialEq, Eq)]
83pub enum DecompressStage {
84 GetFrameHeaderSize = 0,
85 DecodeFrameHeader = 1,
86 DecodeBlockHeader = 2,
87 DecompressBlock = 3,
88 DecompressLastBlock = 4,
89 CheckChecksum = 5,
90 DecodeSkippableHeader = 6,
91 SkipFrame = 7,
92}
93
94impl DecompressStage {
95 pub const fn to_next_input_type(self) -> NextInputType {
96 match self {
97 Self::DecodeBlockHeader => NextInputType::BlockHeader,
98 Self::DecompressBlock => NextInputType::Block,
99 Self::DecompressLastBlock => NextInputType::LastBlock,
100 Self::CheckChecksum => NextInputType::Checksum,
101 Self::DecodeSkippableHeader | Self::SkipFrame => NextInputType::SkippableFrame,
102 Self::GetFrameHeaderSize | Self::DecodeFrameHeader => NextInputType::FrameHeader,
103 }
104 }
105}
106
107#[repr(u32)]
108#[derive(Debug, Clone, Copy, PartialEq, Eq)]
109pub enum NextInputType {
110 FrameHeader = 0,
111 BlockHeader = 1,
112 Block = 2,
113 LastBlock = 3,
114 Checksum = 4,
115 SkippableFrame = 5,
116}
117
118#[repr(u32)]
119#[derive(Debug, Clone, Copy, PartialEq, Eq)]
120pub enum StreamStage {
121 Init,
122 LoadHeader,
123 Read,
124 Load,
125 Flush,
126}
127
128pub type ZSTD_dictUses_e = core::ffi::c_int;
129pub const ZSTD_use_once: ZSTD_dictUses_e = 1;
130pub const ZSTD_dont_use: ZSTD_dictUses_e = 0;
131pub const ZSTD_use_indefinitely: ZSTD_dictUses_e = -1;
132
133#[repr(u32)]
134#[derive(Debug, Clone, Copy, PartialEq, Eq)]
135pub enum LitLocation {
136 ZSTD_split = 2,
137 ZSTD_in_dst = 1,
138 ZSTD_not_in_dst = 0,
139}
140
141pub type ZSTD_forceIgnoreChecksum_e = core::ffi::c_uint;
142pub const ZSTD_d_ignoreChecksum: ZSTD_forceIgnoreChecksum_e = 1;
143pub const ZSTD_d_validateChecksum: ZSTD_forceIgnoreChecksum_e = 0;
144
145pub type ZSTD_FrameType_e = core::ffi::c_uint;
146pub const ZSTD_skippableFrame: ZSTD_FrameType_e = 1;
147pub const ZSTD_frame: ZSTD_FrameType_e = 0;
148
149#[derive(Copy, Clone)]
150#[repr(C)]
151pub struct blockProperties_t {
152 pub blockType: BlockType,
153 pub lastBlock: u32,
154 pub origSize: u32,
155}
156
157#[repr(u32)]
158#[derive(Debug, Clone, Copy, PartialEq, Eq)]
159pub enum BlockType {
160 Raw = 0,
161 Rle = 1,
162 Compressed = 2,
163 Reserved = 3,
164}
165
166impl From<u32> for BlockType {
167 fn from(value: u32) -> Self {
168 match value {
169 0 => Self::Raw,
170 1 => Self::Rle,
171 2 => Self::Compressed,
172 3 => Self::Reserved,
173 _ => panic!("invalid `BlockType`: {value}"),
174 }
175 }
176}
177
178#[derive(Default)]
179#[repr(C)]
180pub struct ZSTD_FrameHeader {
181 pub frameContentSize: core::ffi::c_ulonglong,
182 pub windowSize: core::ffi::c_ulonglong,
183 pub blockSizeMax: core::ffi::c_uint,
184 pub frameType: ZSTD_FrameType_e,
185 pub headerSize: core::ffi::c_uint,
186 pub dictID: core::ffi::c_uint,
187 pub checksumFlag: core::ffi::c_uint,
188 pub _reserved1: core::ffi::c_uint,
189 pub _reserved2: core::ffi::c_uint,
190}
191
192#[repr(C)]
193pub struct Workspace {
194 data: [u32; 640],
195}
196
197impl Workspace {
198 fn as_x1_mut(&mut self) -> &mut huf_decompress::HUF_ReadDTableX1_Workspace {
199 const { assert!(size_of::<Self>() >= size_of::<huf_decompress::HUF_ReadDTableX1_Workspace>()) }
200 const { assert!(align_of::<Self>() >= align_of::<huf_decompress::HUF_ReadDTableX1_Workspace>()) }
201
202 unsafe { core::mem::transmute(&mut self.data) }
203 }
204
205 fn as_x2_mut(&mut self) -> &mut huf_decompress::HUF_ReadDTableX2_Workspace {
206 const { assert!(size_of::<Self>() >= size_of::<huf_decompress::HUF_ReadDTableX2_Workspace>()) }
207 const { assert!(align_of::<Self>() >= align_of::<huf_decompress::HUF_ReadDTableX2_Workspace>()) }
208
209 unsafe { core::mem::transmute(&mut self.data) }
210 }
211
212 fn as_fse_workspace(&mut self) -> &mut FseWorkspace {
213 const { assert!(size_of::<Self>() >= size_of::<FseWorkspace>()) }
214 const { assert!(align_of::<Self>() >= align_of::<FseWorkspace>()) }
215 unsafe { core::mem::transmute(&mut self.data) }
216 }
217}
218
219pub type ZSTD_DCtx = ZSTD_DCtx_s;
220#[repr(C)]
221pub struct ZSTD_DCtx_s {
222 LLTptr: *const ZSTD_seqSymbol,
223 MLTptr: *const ZSTD_seqSymbol,
224 OFTptr: *const ZSTD_seqSymbol,
225 HUFptr: *const DTable,
226 entropy: ZSTD_entropyDTables_t,
227 workspace: Workspace,
228 previousDstEnd: *const core::ffi::c_void,
229 prefixStart: *const core::ffi::c_void,
230 virtualStart: *const core::ffi::c_void,
231 dictEnd: *const core::ffi::c_void,
232 expected: size_t,
233 fParams: ZSTD_FrameHeader,
234 processedCSize: u64,
235 decodedSize: u64,
236 bType: BlockType,
237 stage: DecompressStage,
238 litEntropy: u32,
239 fseEntropy: u32,
240 xxhState: XXH64_state_t,
241 headerSize: size_t,
242 format: Format,
243 forceIgnoreChecksum: ZSTD_forceIgnoreChecksum_e,
244 validateChecksum: u32,
245 litPtr: *const u8,
246 customMem: ZSTD_customMem,
247 litSize: size_t,
248 rleSize: size_t,
249 staticSize: size_t,
250 isFrameDecompression: core::ffi::c_int,
251 bmi2: core::ffi::c_int,
252 ddictLocal: *mut ZSTD_DDict,
253 ddict: *const ZSTD_DDict,
254 dictID: u32,
255 ddictIsCold: core::ffi::c_int,
256 dictUses: ZSTD_dictUses_e,
257 ddictSet: *mut ZSTD_DDictHashSet,
258 refMultipleDDicts: MultipleDDicts,
259 disableHufAsm: core::ffi::c_int,
260 maxBlockSizeParam: core::ffi::c_int,
261 streamStage: StreamStage,
262 inBuff: *mut core::ffi::c_char,
263 inBuffSize: size_t,
264 inPos: size_t,
265 maxWindowSize: size_t,
266 outBuff: *mut core::ffi::c_char,
267 outBuffSize: size_t,
268 outStart: size_t,
269 outEnd: size_t,
270 lhSize: size_t,
271 legacyContext: *mut core::ffi::c_void,
272 previousLegacyVersion: u32,
273 legacyVersion: u32,
274 hostageByte: u32,
275 noForwardProgress: core::ffi::c_int,
276 outBufferMode: BufferMode,
277 expectedOutBuffer: ZSTD_outBuffer,
278 litBuffer: *mut u8,
279 litBufferEnd: *const u8,
280 litBufferLocation: LitLocation,
281 litExtraBuffer: [u8; 65568],
282 headerBuffer: [u8; 18],
283 oversizedDuration: size_t,
284 traceCtx: ZSTD_TraceCtx,
285}