1use core::ptr;
2
3pub type ZSTD_CCtx = ZSTD_CCtx_s;
4#[repr(C)]
5pub struct ZSTD_CCtx_s {
6 pub(super) stage: ZSTD_compressionStage_e,
7 pub(super) cParamsChanged: core::ffi::c_int,
8 pub(super) bmi2: core::ffi::c_int,
9 pub(super) requestedParams: ZSTD_CCtx_params,
10 pub(super) appliedParams: ZSTD_CCtx_params,
11 pub(super) simpleApiParams: ZSTD_CCtx_params,
12 pub(super) dictID: u32,
13 pub(super) dictContentSize: size_t,
14 pub(super) workspace: ZSTD_cwksp,
15 pub(super) blockSizeMax: size_t,
16 pub(super) pledgedSrcSizePlusOne: core::ffi::c_ulonglong,
17 pub(super) consumedSrcSize: core::ffi::c_ulonglong,
18 pub(super) producedCSize: core::ffi::c_ulonglong,
19 pub(super) xxhState: XXH64_state_t,
20 pub(super) customMem: ZSTD_customMem,
21 pub(super) pool: *mut ZSTD_threadPool,
22 pub(super) staticSize: size_t,
23 pub(super) seqCollector: SeqCollector,
24 pub(super) isFirstBlock: core::ffi::c_int,
25 pub(super) initialized: core::ffi::c_int,
26 pub(super) seqStore: SeqStore_t,
27 pub(super) ldmState: ldmState_t,
28 pub(super) ldmSequences: *mut rawSeq,
29 pub(super) maxNbLdmSequences: size_t,
30 pub(super) externSeqStore: RawSeqStore_t,
31 pub(super) blockState: ZSTD_blockState_t,
32 pub(super) tmpWorkspace: *mut core::ffi::c_void,
33 pub(super) tmpWkspSize: size_t,
34 pub(super) bufferedPolicy: ZSTD_buffered_policy_e,
35 pub(super) inBuff: *mut core::ffi::c_char,
36 pub(super) inBuffSize: size_t,
37 pub(super) inToCompress: size_t,
38 pub(super) inBuffPos: size_t,
39 pub(super) inBuffTarget: size_t,
40 pub(super) outBuff: *mut core::ffi::c_char,
41 pub(super) outBuffSize: size_t,
42 pub(super) outBuffContentSize: size_t,
43 pub(super) outBuffFlushedSize: size_t,
44 pub(super) streamStage: ZSTD_cStreamStage,
45 pub(super) frameEnded: u32,
46 pub(super) expectedInBuffer: ZSTD_inBuffer,
47 pub(super) stableIn_notConsumed: size_t,
48 pub(super) expectedOutBufferSize: size_t,
49 pub(super) localDict: ZSTD_localDict,
50 pub(super) cdict: *const ZSTD_CDict,
51 pub(super) prefixDict: ZSTD_prefixDict,
52 pub(super) mtctx: *mut ZSTDMT_CCtx,
53 pub(super) traceCtx: ZSTD_TraceCtx,
54 pub(super) blockSplitCtx: ZSTD_blockSplitCtx,
55 pub(super) extSeqBuf: *mut ZSTD_Sequence,
56 pub(super) extSeqBufCapacity: size_t,
57}
58#[derive(Copy, Clone)]
59#[repr(C)]
60pub struct ZSTD_Sequence {
61 pub offset: core::ffi::c_uint,
62 pub litLength: core::ffi::c_uint,
63 pub matchLength: core::ffi::c_uint,
64 pub rep: core::ffi::c_uint,
65}
66#[derive(Copy, Clone)]
67#[repr(C)]
68pub struct ZSTD_blockSplitCtx {
69 pub fullSeqStoreChunk: SeqStore_t,
70 pub firstHalfSeqStore: SeqStore_t,
71 pub secondHalfSeqStore: SeqStore_t,
72 pub currSeqStore: SeqStore_t,
73 pub nextSeqStore: SeqStore_t,
74 pub partitions: [u32; 196],
75 pub entropyMetadata: ZSTD_entropyCTablesMetadata_t,
76}
77#[derive(Copy, Clone)]
78#[repr(C)]
79pub struct ZSTD_entropyCTablesMetadata_t {
80 pub hufMetadata: ZSTD_hufCTablesMetadata_t,
81 pub fseMetadata: ZSTD_fseCTablesMetadata_t,
82}
83#[derive(Copy, Clone)]
84#[repr(C)]
85pub struct ZSTD_fseCTablesMetadata_t {
86 pub llType: SymbolEncodingType_e,
87 pub ofType: SymbolEncodingType_e,
88 pub mlType: SymbolEncodingType_e,
89 pub fseTablesBuffer: [u8; 133],
90 pub fseTablesSize: size_t,
91 pub lastCountSize: size_t,
92}
93pub type SymbolEncodingType_e = core::ffi::c_uint;
94pub const set_repeat: SymbolEncodingType_e = 3;
95pub const set_compressed: SymbolEncodingType_e = 2;
96pub const set_rle: SymbolEncodingType_e = 1;
97pub const set_basic: SymbolEncodingType_e = 0;
98#[derive(Copy, Clone)]
99#[repr(C)]
100pub struct ZSTD_hufCTablesMetadata_t {
101 pub hType: SymbolEncodingType_e,
102 pub hufDesBuffer: [u8; 128],
103 pub hufDesSize: size_t,
104}
105#[derive(Copy, Clone)]
106#[repr(C)]
107pub struct SeqStore_t {
108 pub sequencesStart: *mut SeqDef,
109 pub sequences: *mut SeqDef,
110 pub litStart: *mut u8,
111 pub lit: *mut u8,
112 pub llCode: *mut u8,
113 pub mlCode: *mut u8,
114 pub ofCode: *mut u8,
115 pub maxNbSeq: size_t,
116 pub maxNbLit: size_t,
117 pub longLengthType: ZSTD_longLengthType_e,
118 pub longLengthPos: u32,
119}
120pub type ZSTD_longLengthType_e = core::ffi::c_uint;
121pub const ZSTD_llt_matchLength: ZSTD_longLengthType_e = 2;
122pub const ZSTD_llt_literalLength: ZSTD_longLengthType_e = 1;
123pub const ZSTD_llt_none: ZSTD_longLengthType_e = 0;
124pub type SeqDef = SeqDef_s;
125#[derive(Copy, Clone)]
126#[repr(C)]
127pub struct SeqDef_s {
128 pub offBase: u32,
129 pub litLength: u16,
130 pub mlBase: u16,
131}
132pub type ZSTD_prefixDict = ZSTD_prefixDict_s;
133#[derive(Copy, Clone)]
134#[repr(C)]
135pub struct ZSTD_prefixDict_s {
136 pub dict: *const core::ffi::c_void,
137 pub dictSize: size_t,
138 pub dictContentType: ZSTD_dictContentType_e,
139}
140pub type ZSTD_dictContentType_e = core::ffi::c_uint;
141pub const ZSTD_dct_fullDict: ZSTD_dictContentType_e = 2;
142pub const ZSTD_dct_rawContent: ZSTD_dictContentType_e = 1;
143pub const ZSTD_dct_auto: ZSTD_dictContentType_e = 0;
144pub type ZSTD_CDict = ZSTD_CDict_s;
145#[repr(C)]
146pub struct ZSTD_CDict_s {
147 pub dictContent: *const core::ffi::c_void,
148 pub dictContentSize: size_t,
149 pub dictContentType: ZSTD_dictContentType_e,
150 pub entropyWorkspace: *mut u32,
151 pub workspace: ZSTD_cwksp,
152 pub matchState: ZSTD_MatchState_t,
153 pub cBlockState: ZSTD_compressedBlockState_t,
154 pub customMem: ZSTD_customMem,
155 pub dictID: u32,
156 pub compressionLevel: core::ffi::c_int,
157 pub useRowMatchFinder: ZSTD_ParamSwitch_e,
158}
159pub type ZSTD_ParamSwitch_e = core::ffi::c_uint;
160pub const ZSTD_ps_disable: ZSTD_ParamSwitch_e = 2;
161pub const ZSTD_ps_enable: ZSTD_ParamSwitch_e = 1;
162pub const ZSTD_ps_auto: ZSTD_ParamSwitch_e = 0;
163#[derive(Copy, Clone)]
164#[repr(C)]
165pub struct ZSTD_compressedBlockState_t {
166 pub entropy: ZSTD_entropyCTables_t,
167 pub rep: [u32; 3],
168}
169#[derive(Copy, Clone)]
170#[repr(C)]
171pub struct ZSTD_entropyCTables_t {
172 pub huf: ZSTD_hufCTables_t,
173 pub fse: ZSTD_fseCTables_t,
174}
175#[derive(Copy, Clone)]
176#[repr(C)]
177pub struct ZSTD_fseCTables_t {
178 pub offcodeCTable: [FSE_CTable; 193],
179 pub matchlengthCTable: [FSE_CTable; 363],
180 pub litlengthCTable: [FSE_CTable; 329],
181 pub offcode_repeatMode: FSE_repeat,
182 pub matchlength_repeatMode: FSE_repeat,
183 pub litlength_repeatMode: FSE_repeat,
184}
185#[derive(Copy, Clone)]
186#[repr(C)]
187pub struct ZSTD_hufCTables_t {
188 pub CTable: [HUF_CElt; 257],
189 pub repeatMode: HUF_repeat,
190}
191#[repr(C)]
192pub struct ZSTD_MatchState_t {
193 pub window: ZSTD_window_t,
194 pub loadedDictEnd: u32,
195 pub nextToUpdate: u32,
196 pub hashLog3: u32,
197 pub rowHashLog: u32,
198 pub tagTable: *mut u8,
199 pub hashCache: [u32; 8],
200 pub hashSalt: u64,
201 pub hashSaltEntropy: u32,
202 pub hashTable: *mut u32,
203 pub hashTable3: *mut u32,
204 pub chainTable: *mut u32,
205 pub forceNonContiguous: core::ffi::c_int,
206 pub dedicatedDictSearch: core::ffi::c_int,
207 pub opt: optState_t,
208 pub dictMatchState: *const ZSTD_MatchState_t,
209 pub cParams: ZSTD_compressionParameters,
210 pub ldmSeqStore: *const RawSeqStore_t,
211 pub prefetchCDictTables: core::ffi::c_int,
212 pub lazySkipping: core::ffi::c_int,
213}
214#[derive(Copy, Clone)]
215#[repr(C)]
216pub struct RawSeqStore_t {
217 pub seq: *mut rawSeq,
218 pub pos: size_t,
219 pub posInSequence: size_t,
220 pub size: size_t,
221 pub capacity: size_t,
222}
223#[derive(Copy, Clone)]
224#[repr(C)]
225pub struct rawSeq {
226 pub offset: u32,
227 pub litLength: u32,
228 pub matchLength: u32,
229}
230#[repr(C)]
231pub struct optState_t {
232 pub litFreq: *mut core::ffi::c_uint,
233 pub litLengthFreq: *mut core::ffi::c_uint,
234 pub matchLengthFreq: *mut core::ffi::c_uint,
235 pub offCodeFreq: *mut core::ffi::c_uint,
236 pub matchTable: *mut ZSTD_match_t,
237 pub priceTable: *mut ZSTD_optimal_t,
238 pub litSum: u32,
239 pub litLengthSum: u32,
240 pub matchLengthSum: u32,
241 pub offCodeSum: u32,
242 pub litSumBasePrice: u32,
243 pub litLengthSumBasePrice: u32,
244 pub matchLengthSumBasePrice: u32,
245 pub offCodeSumBasePrice: u32,
246 pub priceType: ZSTD_OptPrice_e,
247 pub symbolCosts: *const ZSTD_entropyCTables_t,
248 pub literalCompressionMode: ZSTD_ParamSwitch_e,
249}
250pub type ZSTD_OptPrice_e = core::ffi::c_uint;
251pub const zop_predef: ZSTD_OptPrice_e = 1;
252pub const zop_dynamic: ZSTD_OptPrice_e = 0;
253#[derive(Copy, Clone)]
254#[repr(C)]
255pub struct ZSTD_optimal_t {
256 pub price: core::ffi::c_int,
257 pub off: u32,
258 pub mlen: u32,
259 pub litlen: u32,
260 pub rep: [u32; 3],
261}
262#[derive(Copy, Clone)]
263#[repr(C)]
264pub struct ZSTD_match_t {
265 pub off: u32,
266 pub len: u32,
267}
268#[derive(Copy, Clone)]
269#[repr(C)]
270pub struct ZSTD_window_t {
271 pub nextSrc: *const u8,
272 pub base: *const u8,
273 pub dictBase: *const u8,
274 pub dictLimit: u32,
275 pub lowLimit: u32,
276 pub nbOverflowCorrections: u32,
277}
278#[derive(Copy, Clone)]
279#[repr(C)]
280pub struct ZSTD_cwksp {
281 pub workspace: *mut core::ffi::c_void,
282 pub workspaceEnd: *mut core::ffi::c_void,
283 pub objectEnd: *mut core::ffi::c_void,
284 pub tableEnd: *mut core::ffi::c_void,
285 pub tableValidEnd: *mut core::ffi::c_void,
286 pub allocStart: *mut core::ffi::c_void,
287 pub initOnceStart: *mut core::ffi::c_void,
288 pub allocFailed: u8,
289 pub workspaceOversizedDuration: core::ffi::c_int,
290 pub phase: ZSTD_cwksp_alloc_phase_e,
291 pub isStatic: ZSTD_cwksp_static_alloc_e,
292}
293pub type ZSTD_cwksp_static_alloc_e = core::ffi::c_uint;
294pub const ZSTD_cwksp_static_alloc: ZSTD_cwksp_static_alloc_e = 1;
295pub const ZSTD_cwksp_dynamic_alloc: ZSTD_cwksp_static_alloc_e = 0;
296pub type ZSTD_cwksp_alloc_phase_e = core::ffi::c_uint;
297pub const ZSTD_cwksp_alloc_buffers: ZSTD_cwksp_alloc_phase_e = 3;
298pub const ZSTD_cwksp_alloc_aligned: ZSTD_cwksp_alloc_phase_e = 2;
299pub const ZSTD_cwksp_alloc_aligned_init_once: ZSTD_cwksp_alloc_phase_e = 1;
300pub const ZSTD_cwksp_alloc_objects: ZSTD_cwksp_alloc_phase_e = 0;
301#[derive(Copy, Clone)]
302#[repr(C)]
303pub struct ZSTD_localDict {
304 pub dictBuffer: *mut core::ffi::c_void,
305 pub dict: *const core::ffi::c_void,
306 pub dictSize: size_t,
307 pub dictContentType: ZSTD_dictContentType_e,
308 pub cdict: *mut ZSTD_CDict,
309}
310pub type ZSTD_cStreamStage = core::ffi::c_uint;
311pub const zcss_flush: ZSTD_cStreamStage = 2;
312pub const zcss_load: ZSTD_cStreamStage = 1;
313pub const zcss_init: ZSTD_cStreamStage = 0;
314pub type ZSTD_buffered_policy_e = core::ffi::c_uint;
315pub const ZSTDb_buffered: ZSTD_buffered_policy_e = 1;
316pub const ZSTDb_not_buffered: ZSTD_buffered_policy_e = 0;
317#[repr(C)]
318pub struct ZSTD_blockState_t {
319 pub prevCBlock: *mut ZSTD_compressedBlockState_t,
320 pub nextCBlock: *mut ZSTD_compressedBlockState_t,
321 pub matchState: ZSTD_MatchState_t,
322}
323#[repr(C)]
324pub struct SeqCollector {
325 pub collectSequences: core::ffi::c_int,
326 pub seqStart: *mut ZSTD_Sequence,
327 pub seqIndex: size_t,
328 pub maxSequences: size_t,
329}
330pub type ZSTD_CCtx_params = ZSTD_CCtx_params_s;
331#[derive(Copy, Clone)]
332#[repr(C)]
333pub struct ZSTD_CCtx_params_s {
334 pub format: Format,
335 pub cParams: ZSTD_compressionParameters,
336 pub fParams: ZSTD_frameParameters,
337 pub compressionLevel: core::ffi::c_int,
338 pub forceWindow: core::ffi::c_int,
339 pub targetCBlockSize: size_t,
340 pub srcSizeHint: core::ffi::c_int,
341 pub attachDictPref: ZSTD_dictAttachPref_e,
342 pub literalCompressionMode: ZSTD_ParamSwitch_e,
343 pub nbWorkers: core::ffi::c_int,
344 pub jobSize: size_t,
345 pub overlapLog: core::ffi::c_int,
346 pub rsyncable: core::ffi::c_int,
347 pub ldmParams: ldmParams_t,
348 pub enableDedicatedDictSearch: core::ffi::c_int,
349 pub inBufferMode: ZSTD_bufferMode_e,
350 pub outBufferMode: ZSTD_bufferMode_e,
351 pub blockDelimiters: ZSTD_SequenceFormat_e,
352 pub validateSequences: core::ffi::c_int,
353 pub postBlockSplitter: ZSTD_ParamSwitch_e,
354 pub preBlockSplitter_level: core::ffi::c_int,
355 pub maxBlockSize: size_t,
356 pub useRowMatchFinder: ZSTD_ParamSwitch_e,
357 pub deterministicRefPrefix: core::ffi::c_int,
358 pub customMem: ZSTD_customMem,
359 pub prefetchCDictTables: ZSTD_ParamSwitch_e,
360 pub enableMatchFinderFallback: core::ffi::c_int,
361 pub extSeqProdState: *mut core::ffi::c_void,
362 pub extSeqProdFunc: ZSTD_sequenceProducer_F,
363 pub searchForExternalRepcodes: ZSTD_ParamSwitch_e,
364}
365pub type ZSTD_sequenceProducer_F = Option<
366 unsafe extern "C" fn(
367 *mut core::ffi::c_void,
368 *mut ZSTD_Sequence,
369 size_t,
370 *const core::ffi::c_void,
371 size_t,
372 *const core::ffi::c_void,
373 size_t,
374 core::ffi::c_int,
375 size_t,
376 ) -> size_t,
377>;
378pub type ZSTD_SequenceFormat_e = core::ffi::c_uint;
379pub const ZSTD_sf_explicitBlockDelimiters: ZSTD_SequenceFormat_e = 1;
380pub const ZSTD_sf_noBlockDelimiters: ZSTD_SequenceFormat_e = 0;
381pub type ZSTD_dictAttachPref_e = core::ffi::c_uint;
382pub const ZSTD_dictForceLoad: ZSTD_dictAttachPref_e = 3;
383pub const ZSTD_dictForceCopy: ZSTD_dictAttachPref_e = 2;
384pub const ZSTD_dictForceAttach: ZSTD_dictAttachPref_e = 1;
385pub const ZSTD_dictDefaultAttach: ZSTD_dictAttachPref_e = 0;
386pub type ZSTD_compressionStage_e = core::ffi::c_uint;
387pub const ZSTDcs_ending: ZSTD_compressionStage_e = 3;
388pub const ZSTDcs_ongoing: ZSTD_compressionStage_e = 2;
389pub const ZSTDcs_init: ZSTD_compressionStage_e = 1;
390pub const ZSTDcs_created: ZSTD_compressionStage_e = 0;
391pub type unalignArch = size_t;
392#[derive(Copy, Clone)]
393#[repr(C)]
394pub struct ZSTD_symbolEncodingTypeStats_t {
395 pub LLtype: u32,
396 pub Offtype: u32,
397 pub MLtype: u32,
398 pub size: size_t,
399 pub lastCountSize: size_t,
400 pub longOffsets: core::ffi::c_int,
401}
402pub type S16 = i16;
403pub type ZSTD_DefaultPolicy_e = core::ffi::c_uint;
404pub const ZSTD_defaultAllowed: ZSTD_DefaultPolicy_e = 1;
405pub const ZSTD_defaultDisallowed: ZSTD_DefaultPolicy_e = 0;
406pub type Repcodes_t = repcodes_s;
407#[derive(Copy, Clone)]
408#[repr(C)]
409pub struct repcodes_s {
410 pub rep: [u32; 3],
411}
412pub const ZSTDbss_noCompress: C2RustUnnamed_2 = 1;
413pub const ZSTDbss_compress: C2RustUnnamed_2 = 0;
414pub type ZSTD_BlockCompressor_f = Option<
415 unsafe fn(
416 *mut ZSTD_MatchState_t,
417 *mut SeqStore_t,
418 *mut u32,
419 *const core::ffi::c_void,
420 size_t,
421 ) -> size_t,
422>;
423pub type ZSTD_dictMode_e = core::ffi::c_uint;
424pub const ZSTD_dedicatedDictSearch: ZSTD_dictMode_e = 3;
425pub const ZSTD_dictMatchState: ZSTD_dictMode_e = 2;
426pub const ZSTD_extDict: ZSTD_dictMode_e = 1;
427pub const ZSTD_noDict: ZSTD_dictMode_e = 0;
428#[derive(Copy, Clone)]
429#[repr(C)]
430pub struct ZSTD_SequencePosition {
431 pub idx: u32,
432 pub posInSequence: u32,
433 pub posInSrc: size_t,
434}
435pub type S64 = i64;
436#[repr(C)]
437pub struct seqStoreSplits {
438 pub splitLocations: *mut u32,
439 pub idx: size_t,
440}
441
442pub type ZSTD_dictTableLoadMethod_e = core::ffi::c_uint;
443pub const ZSTD_dtlm_full: ZSTD_dictTableLoadMethod_e = 1;
444pub const ZSTD_dtlm_fast: ZSTD_dictTableLoadMethod_e = 0;
445pub type ZSTD_tableFillPurpose_e = core::ffi::c_uint;
446pub const ZSTD_tfp_forCDict: ZSTD_tableFillPurpose_e = 1;
447pub const ZSTD_tfp_forCCtx: ZSTD_tableFillPurpose_e = 0;
448pub type ZSTD_compResetPolicy_e = core::ffi::c_uint;
449pub const ZSTDcrp_leaveDirty: ZSTD_compResetPolicy_e = 1;
450pub const ZSTDcrp_makeClean: ZSTD_compResetPolicy_e = 0;
451pub type ZSTD_resetTarget_e = core::ffi::c_uint;
452pub const ZSTD_resetTarget_CCtx: ZSTD_resetTarget_e = 1;
453pub const ZSTD_resetTarget_CDict: ZSTD_resetTarget_e = 0;
454pub type ZSTD_indexResetPolicy_e = core::ffi::c_uint;
455pub const ZSTDirp_reset: ZSTD_indexResetPolicy_e = 1;
456pub const ZSTDirp_continue: ZSTD_indexResetPolicy_e = 0;
457pub type ZSTD_CParamMode_e = core::ffi::c_uint;
458pub const ZSTD_cpm_unknown: ZSTD_CParamMode_e = 3;
459pub const ZSTD_cpm_createCDict: ZSTD_CParamMode_e = 2;
460pub const ZSTD_cpm_attachDict: ZSTD_CParamMode_e = 1;
461pub const ZSTD_cpm_noAttachDict: ZSTD_CParamMode_e = 0;
462pub type ZSTD_ResetDirective = core::ffi::c_uint;
463pub const ZSTD_reset_session_and_parameters: ZSTD_ResetDirective = 3;
464pub const ZSTD_reset_parameters: ZSTD_ResetDirective = 2;
465pub const ZSTD_reset_session_only: ZSTD_ResetDirective = 1;
466#[derive(Copy, Clone)]
467#[repr(C)]
468pub struct ZSTD_cpuid_t {
469 pub f1c: u32,
470 pub f1d: u32,
471 pub f7b: u32,
472 pub f7c: u32,
473}
474pub type ZSTD_cParameter = core::ffi::c_uint;
475pub const ZSTD_c_experimentalParam20: ZSTD_cParameter = 1017;
476pub const ZSTD_c_experimentalParam19: ZSTD_cParameter = 1016;
477pub const ZSTD_c_experimentalParam18: ZSTD_cParameter = 1015;
478pub const ZSTD_c_experimentalParam17: ZSTD_cParameter = 1014;
479pub const ZSTD_c_experimentalParam16: ZSTD_cParameter = 1013;
480pub const ZSTD_c_experimentalParam15: ZSTD_cParameter = 1012;
481pub const ZSTD_c_experimentalParam14: ZSTD_cParameter = 1011;
482pub const ZSTD_c_experimentalParam13: ZSTD_cParameter = 1010;
483pub const ZSTD_c_experimentalParam12: ZSTD_cParameter = 1009;
484pub const ZSTD_c_experimentalParam11: ZSTD_cParameter = 1008;
485pub const ZSTD_c_experimentalParam10: ZSTD_cParameter = 1007;
486pub const ZSTD_c_experimentalParam9: ZSTD_cParameter = 1006;
487pub const ZSTD_c_experimentalParam8: ZSTD_cParameter = 1005;
488pub const ZSTD_c_experimentalParam7: ZSTD_cParameter = 1004;
489pub const ZSTD_c_experimentalParam5: ZSTD_cParameter = 1002;
490pub const ZSTD_c_experimentalParam4: ZSTD_cParameter = 1001;
491pub const ZSTD_c_experimentalParam3: ZSTD_cParameter = 1000;
492pub const ZSTD_c_experimentalParam2: ZSTD_cParameter = 10;
493pub const ZSTD_c_experimentalParam1: ZSTD_cParameter = 500;
494pub const ZSTD_c_overlapLog: ZSTD_cParameter = 402;
495pub const ZSTD_c_jobSize: ZSTD_cParameter = 401;
496pub const ZSTD_c_nbWorkers: ZSTD_cParameter = 400;
497pub const ZSTD_c_dictIDFlag: ZSTD_cParameter = 202;
498pub const ZSTD_c_checksumFlag: ZSTD_cParameter = 201;
499pub const ZSTD_c_contentSizeFlag: ZSTD_cParameter = 200;
500pub const ZSTD_c_ldmHashRateLog: ZSTD_cParameter = 164;
501pub const ZSTD_c_ldmBucketSizeLog: ZSTD_cParameter = 163;
502pub const ZSTD_c_ldmMinMatch: ZSTD_cParameter = 162;
503pub const ZSTD_c_ldmHashLog: ZSTD_cParameter = 161;
504pub const ZSTD_c_enableLongDistanceMatching: ZSTD_cParameter = 160;
505pub const ZSTD_c_targetCBlockSize: ZSTD_cParameter = 130;
506pub const ZSTD_c_strategy: ZSTD_cParameter = 107;
507pub const ZSTD_c_targetLength: ZSTD_cParameter = 106;
508pub const ZSTD_c_minMatch: ZSTD_cParameter = 105;
509pub const ZSTD_c_searchLog: ZSTD_cParameter = 104;
510pub const ZSTD_c_chainLog: ZSTD_cParameter = 103;
511pub const ZSTD_c_hashLog: ZSTD_cParameter = 102;
512pub const ZSTD_c_windowLog: ZSTD_cParameter = 101;
513pub const ZSTD_c_compressionLevel: ZSTD_cParameter = 100;
514#[derive(Copy, Clone)]
515#[repr(C)]
516pub struct ZSTD_bounds {
517 pub error: size_t,
518 pub lowerBound: core::ffi::c_int,
519 pub upperBound: core::ffi::c_int,
520}
521pub type ZSTD_EndDirective = core::ffi::c_uint;
522pub const ZSTD_e_end: ZSTD_EndDirective = 2;
523pub const ZSTD_e_flush: ZSTD_EndDirective = 1;
524pub const ZSTD_e_continue: ZSTD_EndDirective = 0;
525pub type ZSTD_CStream = ZSTD_CCtx;
526pub type ZSTD_dictLoadMethod_e = core::ffi::c_uint;
527pub const ZSTD_dlm_byRef: ZSTD_dictLoadMethod_e = 1;
528pub const ZSTD_dlm_byCopy: ZSTD_dictLoadMethod_e = 0;
529pub type ZSTD_SequenceCopier_f = Option<
530 unsafe fn(
531 *mut ZSTD_CCtx,
532 *mut ZSTD_SequencePosition,
533 *const ZSTD_Sequence,
534 size_t,
535 *const core::ffi::c_void,
536 size_t,
537 ZSTD_ParamSwitch_e,
538 ) -> size_t,
539>;
540#[derive(Copy, Clone)]
541#[repr(C)]
542pub struct BlockSummary {
543 pub nbSequences: size_t,
544 pub blockSize: size_t,
545 pub litSize: size_t,
546}
547pub type C2RustUnnamed_2 = core::ffi::c_uint;
548pub const ZSTD_VERSION_MAJOR: core::ffi::c_int = 1;
549pub const ZSTD_VERSION_MINOR: core::ffi::c_int = 5;
550pub const ZSTD_VERSION_RELEASE: core::ffi::c_int = 8;
551pub const ZSTD_VERSION_NUMBER: core::ffi::c_int =
552 ZSTD_VERSION_MAJOR * 100 * 100 + ZSTD_VERSION_MINOR * 100 + ZSTD_VERSION_RELEASE;
553pub const ZSTD_CLEVEL_DEFAULT: core::ffi::c_int = 3;
554pub const ZSTD_MAGICNUMBER: core::ffi::c_uint = 0xfd2fb528 as core::ffi::c_uint;
555pub const ZSTD_MAGIC_DICTIONARY: core::ffi::c_uint = 0xec30a437 as core::ffi::c_uint;
556pub const ZSTD_MAGIC_SKIPPABLE_START: core::ffi::c_int = 0x184d2a50 as core::ffi::c_int;
557pub const ZSTD_BLOCKSIZELOG_MAX: core::ffi::c_int = 17;
558pub const ZSTD_BLOCKSIZE_MAX: core::ffi::c_int = (1) << ZSTD_BLOCKSIZELOG_MAX;
559pub const ZSTD_CONTENTSIZE_UNKNOWN: core::ffi::c_ulonglong =
560 (0 as core::ffi::c_ulonglong).wrapping_sub(1);
561pub const ZSTD_SKIPPABLEHEADERSIZE: core::ffi::c_int = 8;
562pub const ZSTD_WINDOWLOG_MAX_32: core::ffi::c_int = 30;
563pub const ZSTD_WINDOWLOG_MAX_64: core::ffi::c_int = 31;
564pub const ZSTD_WINDOWLOG_MIN: core::ffi::c_int = 10;
565pub const ZSTD_HASHLOG_MIN: core::ffi::c_int = 6;
566pub const ZSTD_CHAINLOG_MAX_32: core::ffi::c_int = 29;
567pub const ZSTD_CHAINLOG_MAX_64: core::ffi::c_int = 30;
568pub const ZSTD_CHAINLOG_MIN: core::ffi::c_int = ZSTD_HASHLOG_MIN;
569pub const ZSTD_SEARCHLOG_MIN: core::ffi::c_int = 1;
570pub const ZSTD_MINMATCH_MAX: core::ffi::c_int = 7;
571pub const ZSTD_MINMATCH_MIN: core::ffi::c_int = 3;
572pub const ZSTD_TARGETLENGTH_MAX: core::ffi::c_int = ZSTD_BLOCKSIZE_MAX;
573pub const ZSTD_TARGETLENGTH_MIN: core::ffi::c_int = 0;
574pub const ZSTD_STRATEGY_MIN: core::ffi::c_int = ZSTD_fast as core::ffi::c_int;
575pub const ZSTD_STRATEGY_MAX: core::ffi::c_int = ZSTD_btultra2 as core::ffi::c_int;
576pub const ZSTD_BLOCKSIZE_MAX_MIN: core::ffi::c_int = (1) << 10;
577pub const ZSTD_OVERLAPLOG_MIN: core::ffi::c_int = 0;
578pub const ZSTD_OVERLAPLOG_MAX: core::ffi::c_int = 9;
579pub const ZSTD_WINDOWLOG_LIMIT_DEFAULT: core::ffi::c_int = 27;
580pub const ZSTD_LDM_HASHLOG_MIN: core::ffi::c_int = ZSTD_HASHLOG_MIN;
581pub const ZSTD_LDM_MINMATCH_MIN: core::ffi::c_int = 4;
582pub const ZSTD_LDM_MINMATCH_MAX: core::ffi::c_int = 4096;
583pub const ZSTD_LDM_BUCKETSIZELOG_MIN: core::ffi::c_int = 1;
584pub const ZSTD_LDM_BUCKETSIZELOG_MAX: core::ffi::c_int = 8;
585pub const ZSTD_LDM_HASHRATELOG_MIN: core::ffi::c_int = 0;
586pub const ZSTD_TARGETCBLOCKSIZE_MIN: core::ffi::c_int = 1340;
587pub const ZSTD_TARGETCBLOCKSIZE_MAX: core::ffi::c_int = ZSTD_BLOCKSIZE_MAX;
588pub const ZSTD_SRCSIZEHINT_MIN: core::ffi::c_int = 0;
589pub const ZSTD_SRCSIZEHINT_MAX: core::ffi::c_int = INT_MAX;
590pub const ZSTD_c_rsyncable: core::ffi::c_int = 500;
591pub const ZSTD_c_format: core::ffi::c_int = 10;
592pub const ZSTD_c_forceMaxWindow: core::ffi::c_int = 1000;
593pub const ZSTD_c_forceAttachDict: core::ffi::c_int = 1001;
594pub const ZSTD_c_literalCompressionMode: core::ffi::c_int = 1002;
595pub const ZSTD_c_srcSizeHint: core::ffi::c_int = 1004;
596pub const ZSTD_c_enableDedicatedDictSearch: core::ffi::c_int = 1005;
597pub const ZSTD_c_stableInBuffer: core::ffi::c_int = 1006;
598pub const ZSTD_c_stableOutBuffer: core::ffi::c_int = 1007;
599pub const ZSTD_c_blockDelimiters: core::ffi::c_int = 1008;
600pub const ZSTD_c_validateSequences: core::ffi::c_int = 1009;
601pub const ZSTD_BLOCKSPLITTER_LEVEL_MAX: core::ffi::c_int = 6;
602pub const ZSTD_c_blockSplitterLevel: core::ffi::c_int = 1017;
603pub const ZSTD_c_splitAfterSequences: core::ffi::c_int = 1010;
604pub const ZSTD_c_useRowMatchFinder: core::ffi::c_int = 1011;
605pub const ZSTD_c_deterministicRefPrefix: core::ffi::c_int = 1012;
606pub const ZSTD_c_prefetchCDictTables: core::ffi::c_int = 1013;
607pub const ZSTD_c_enableSeqProducerFallback: core::ffi::c_int = 1014;
608pub const ZSTD_c_maxBlockSize: core::ffi::c_int = 1015;
609pub const ZSTD_c_repcodeResolution: core::ffi::c_int = 1016;
610pub const HASH_READ_SIZE: core::ffi::c_int = 8;
611pub const ZSTD_DUBT_UNSORTED_MARK: core::ffi::c_int = 1;
612static mut kNullRawSeqStore: RawSeqStore_t = RawSeqStore_t {
613 seq: core::ptr::null_mut(),
614 pos: 0,
615 posInSequence: 0,
616 size: 0,
617 capacity: 0,
618};
619pub const ZSTD_OPT_SIZE: core::ffi::c_int = ZSTD_OPT_NUM + 3;
620pub const ZSTD_WINDOW_START_INDEX: core::ffi::c_int = 2;
621pub const ZSTD_MAX_NB_BLOCK_SPLITS: core::ffi::c_int = 196;
622#[inline]
623unsafe fn ZSTD_LLcode(litLength: u32) -> u32 {
624 static LL_Code: [u8; 64] = [
625 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20,
626 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
627 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
628 ];
629 static LL_deltaCode: u32 = 19;
630 if litLength > 63 {
631 (ZSTD_highbit32(litLength)).wrapping_add(LL_deltaCode)
632 } else {
633 *LL_Code.as_ptr().offset(litLength as isize) as core::ffi::c_uint
634 }
635}
636#[inline]
637unsafe fn ZSTD_MLcode(mlBase: u32) -> u32 {
638 static ML_Code: [u8; 128] = [
639 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,
640 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
641 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40,
642 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
643 41, 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
644 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
645 ];
646 static ML_deltaCode: u32 = 36;
647 if mlBase > 127 {
648 (ZSTD_highbit32(mlBase)).wrapping_add(ML_deltaCode)
649 } else {
650 *ML_Code.as_ptr().offset(mlBase as isize) as core::ffi::c_uint
651 }
652}
653#[inline]
654unsafe fn ZSTD_cParam_withinBounds(
655 cParam: ZSTD_cParameter,
656 value: core::ffi::c_int,
657) -> core::ffi::c_int {
658 let bounds = ZSTD_cParam_getBounds(cParam);
659 if ERR_isError(bounds.error) {
660 return 0;
661 }
662 if value < bounds.lowerBound {
663 return 0;
664 }
665 if value > bounds.upperBound {
666 return 0;
667 }
668 1
669}
670#[inline]
671unsafe fn ZSTD_noCompressBlock(
672 dst: *mut core::ffi::c_void,
673 dstCapacity: size_t,
674 src: *const core::ffi::c_void,
675 srcSize: size_t,
676 lastBlock: u32,
677) -> size_t {
678 let cBlockHeader24 = lastBlock
679 .wrapping_add((bt_raw as core::ffi::c_int as u32) << 1)
680 .wrapping_add((srcSize << 3) as u32);
681 if srcSize.wrapping_add(ZSTD_blockHeaderSize) > dstCapacity {
682 return Error::dstSize_tooSmall.to_error_code();
683 }
684 MEM_writeLE24(dst, cBlockHeader24);
685 libc::memcpy(
686 (dst as *mut u8).add(ZSTD_blockHeaderSize) as *mut core::ffi::c_void,
687 src,
688 srcSize as libc::size_t,
689 );
690 ZSTD_blockHeaderSize.wrapping_add(srcSize)
691}
692#[inline]
693unsafe fn ZSTD_rleCompressBlock(
694 dst: *mut core::ffi::c_void,
695 dstCapacity: size_t,
696 src: u8,
697 srcSize: size_t,
698 lastBlock: u32,
699) -> size_t {
700 let op = dst as *mut u8;
701 let cBlockHeader = lastBlock
702 .wrapping_add((bt_rle as core::ffi::c_int as u32) << 1)
703 .wrapping_add((srcSize << 3) as u32);
704 if dstCapacity < 4 {
705 return Error::dstSize_tooSmall.to_error_code();
706 }
707 MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader);
708 *op.offset(3) = src;
709 4
710}
711#[inline]
712unsafe fn ZSTD_minGain(srcSize: size_t, strat: ZSTD_strategy) -> size_t {
713 let minlog =
714 if strat as core::ffi::c_uint >= ZSTD_btultra as core::ffi::c_int as core::ffi::c_uint {
715 strat.wrapping_sub(1)
716 } else {
717 6
718 };
719 (srcSize >> minlog).wrapping_add(2)
720}
721#[inline]
722unsafe fn ZSTD_literalsCompressionIsDisabled(
723 cctxParams: *const ZSTD_CCtx_params,
724) -> core::ffi::c_int {
725 match (*cctxParams).literalCompressionMode as core::ffi::c_uint {
726 1 => 0,
727 2 => 1,
728 0 | _ => {
729 ((*cctxParams).cParams.strategy as core::ffi::c_uint
730 == ZSTD_fast as core::ffi::c_int as core::ffi::c_uint
731 && (*cctxParams).cParams.targetLength > 0) as core::ffi::c_int
732 }
733 }
734}
735unsafe fn ZSTD_safecopyLiterals(
736 mut op: *mut u8,
737 mut ip: *const u8,
738 iend: *const u8,
739 ilimit_w: *const u8,
740) {
741 if ip <= ilimit_w {
742 ZSTD_wildcopy(
743 op as *mut core::ffi::c_void,
744 ip as *const core::ffi::c_void,
745 ilimit_w.offset_from(ip) as size_t,
746 Overlap::NoOverlap,
747 );
748 op = op.offset(ilimit_w.offset_from(ip) as core::ffi::c_long as isize);
749 ip = ilimit_w;
750 }
751 while ip < iend {
752 let fresh0 = ip;
753 ip = ip.offset(1);
754 let fresh1 = op;
755 op = op.offset(1);
756 *fresh1 = *fresh0;
757 }
758}
759pub const REPCODE1_TO_OFFBASE: core::ffi::c_int = 1;
760pub const REPCODE3_TO_OFFBASE: core::ffi::c_int = 3;
761#[inline(always)]
762unsafe fn ZSTD_storeSeqOnly(
763 seqStorePtr: *mut SeqStore_t,
764 litLength: size_t,
765 offBase: u32,
766 matchLength: size_t,
767) {
768 if (litLength > 0xffff as core::ffi::c_int as size_t) as core::ffi::c_int as core::ffi::c_long
769 != 0
770 {
771 (*seqStorePtr).longLengthType = ZSTD_llt_literalLength;
772 (*seqStorePtr).longLengthPos = ((*seqStorePtr).sequences)
773 .offset_from((*seqStorePtr).sequencesStart)
774 as core::ffi::c_long as u32;
775 }
776 (*((*seqStorePtr).sequences).offset(0)).litLength = litLength as u16;
777 (*((*seqStorePtr).sequences).offset(0)).offBase = offBase;
778 let mlBase = matchLength.wrapping_sub(MINMATCH as size_t);
779 if (mlBase > 0xffff as core::ffi::c_int as size_t) as core::ffi::c_int as core::ffi::c_long != 0
780 {
781 (*seqStorePtr).longLengthType = ZSTD_llt_matchLength;
782 (*seqStorePtr).longLengthPos = ((*seqStorePtr).sequences)
783 .offset_from((*seqStorePtr).sequencesStart)
784 as core::ffi::c_long as u32;
785 }
786 (*((*seqStorePtr).sequences).offset(0)).mlBase = mlBase as u16;
787 (*seqStorePtr).sequences = ((*seqStorePtr).sequences).offset(1);
788 (*seqStorePtr).sequences;
789}
790#[inline(always)]
791unsafe fn ZSTD_storeSeq(
792 seqStorePtr: *mut SeqStore_t,
793 litLength: size_t,
794 literals: *const u8,
795 litLimit: *const u8,
796 offBase: u32,
797 matchLength: size_t,
798) {
799 let litLimit_w = litLimit.sub(WILDCOPY_OVERLENGTH);
800 let litEnd = literals.add(litLength);
801 if litEnd <= litLimit_w {
802 ZSTD_copy16(
803 (*seqStorePtr).lit as *mut core::ffi::c_void,
804 literals as *const core::ffi::c_void,
805 );
806 if litLength > 16 {
807 ZSTD_wildcopy(
808 ((*seqStorePtr).lit).offset(16) as *mut core::ffi::c_void,
809 literals.offset(16) as *const core::ffi::c_void,
810 litLength.wrapping_sub(16),
811 Overlap::NoOverlap,
812 );
813 }
814 } else {
815 ZSTD_safecopyLiterals((*seqStorePtr).lit, literals, litEnd, litLimit_w);
816 }
817 (*seqStorePtr).lit = ((*seqStorePtr).lit).add(litLength);
818 ZSTD_storeSeqOnly(seqStorePtr, litLength, offBase, matchLength);
819}
820#[inline]
821unsafe fn ZSTD_updateRep(rep: *mut u32, offBase: u32, ll0: u32) {
822 if offBase > ZSTD_REP_NUM as u32 {
823 *rep.offset(2) = *rep.offset(1);
824 *rep.offset(1) = *rep.offset(0);
825 *rep.offset(0) = offBase.wrapping_sub(ZSTD_REP_NUM as u32);
826 } else {
827 let repCode = offBase.wrapping_sub(1).wrapping_add(ll0);
828 if repCode > 0 {
829 let currentOffset = if repCode == ZSTD_REP_NUM as u32 {
830 (*rep.offset(0)).wrapping_sub(1)
831 } else {
832 *rep.offset(repCode as isize)
833 };
834 *rep.offset(2) = if repCode >= 2 {
835 *rep.offset(1)
836 } else {
837 *rep.offset(2)
838 };
839 *rep.offset(1) = *rep.offset(0);
840 *rep.offset(0) = currentOffset;
841 }
842 };
843}
844#[inline]
845unsafe fn ZSTD_count(mut pIn: *const u8, mut pMatch: *const u8, pInLimit: *const u8) -> size_t {
846 let pStart = pIn;
847 let pInLoopLimit =
848 pInLimit.offset(-((::core::mem::size_of::<size_t>()).wrapping_sub(1) as isize));
849 if pIn < pInLoopLimit {
850 let diff = MEM_readST(pMatch as *const core::ffi::c_void)
851 ^ MEM_readST(pIn as *const core::ffi::c_void);
852 if diff != 0 {
853 return ZSTD_NbCommonBytes(diff) as size_t;
854 }
855 pIn = pIn.add(::core::mem::size_of::<size_t>());
856 pMatch = pMatch.add(::core::mem::size_of::<size_t>());
857 while pIn < pInLoopLimit {
858 let diff_0 = MEM_readST(pMatch as *const core::ffi::c_void)
859 ^ MEM_readST(pIn as *const core::ffi::c_void);
860 if diff_0 == 0 {
861 pIn = pIn.add(::core::mem::size_of::<size_t>());
862 pMatch = pMatch.add(::core::mem::size_of::<size_t>());
863 } else {
864 pIn = pIn.offset(ZSTD_NbCommonBytes(diff_0) as isize);
865 return pIn.offset_from(pStart) as size_t;
866 }
867 }
868 }
869 if MEM_64bits() != 0
870 && pIn < pInLimit.offset(-(3))
871 && MEM_read32(pMatch as *const core::ffi::c_void)
872 == MEM_read32(pIn as *const core::ffi::c_void)
873 {
874 pIn = pIn.offset(4);
875 pMatch = pMatch.offset(4);
876 }
877 if pIn < pInLimit.offset(-(1))
878 && MEM_read16(pMatch as *const core::ffi::c_void) as core::ffi::c_int
879 == MEM_read16(pIn as *const core::ffi::c_void) as core::ffi::c_int
880 {
881 pIn = pIn.offset(2);
882 pMatch = pMatch.offset(2);
883 }
884 if pIn < pInLimit && *pMatch as core::ffi::c_int == *pIn as core::ffi::c_int {
885 pIn = pIn.offset(1);
886 }
887 pIn.offset_from(pStart) as size_t
888}
889#[inline]
890unsafe fn ZSTD_window_clear(window: *mut ZSTD_window_t) {
891 let endT = ((*window).nextSrc).offset_from((*window).base) as size_t;
892 let end = endT as u32;
893 (*window).lowLimit = end;
894 (*window).dictLimit = end;
895}
896#[inline]
897unsafe fn ZSTD_window_hasExtDict(window: ZSTD_window_t) -> u32 {
898 (window.lowLimit < window.dictLimit) as core::ffi::c_int as u32
899}
900#[inline]
901unsafe fn ZSTD_matchState_dictMode(ms: *const ZSTD_MatchState_t) -> ZSTD_dictMode_e {
902 (if ZSTD_window_hasExtDict((*ms).window) != 0 {
903 ZSTD_extDict as core::ffi::c_int
904 } else if !((*ms).dictMatchState).is_null() {
905 if (*(*ms).dictMatchState).dedicatedDictSearch != 0 {
906 ZSTD_dedicatedDictSearch as core::ffi::c_int
907 } else {
908 ZSTD_dictMatchState as core::ffi::c_int
909 }
910 } else {
911 ZSTD_noDict as core::ffi::c_int
912 }) as ZSTD_dictMode_e
913}
914pub const ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY: core::ffi::c_int = 0;
915#[inline]
916unsafe fn ZSTD_window_canOverflowCorrect(
917 window: ZSTD_window_t,
918 cycleLog: u32,
919 maxDist: u32,
920 loadedDictEnd: u32,
921 src: *const core::ffi::c_void,
922) -> u32 {
923 let cycleSize = (1 as core::ffi::c_uint) << cycleLog;
924 let curr = (src as *const u8).offset_from(window.base) as core::ffi::c_long as u32;
925 let minIndexToOverflowCorrect = cycleSize
926 .wrapping_add(if maxDist > cycleSize {
927 maxDist
928 } else {
929 cycleSize
930 })
931 .wrapping_add(ZSTD_WINDOW_START_INDEX as u32);
932 let adjustment = (window.nbOverflowCorrections).wrapping_add(1);
933 let adjustedIndex = if minIndexToOverflowCorrect * adjustment > minIndexToOverflowCorrect {
934 minIndexToOverflowCorrect * adjustment
935 } else {
936 minIndexToOverflowCorrect
937 };
938 let indexLargeEnough = (curr > adjustedIndex) as core::ffi::c_int as u32;
939 let dictionaryInvalidated =
940 (curr > maxDist.wrapping_add(loadedDictEnd)) as core::ffi::c_int as u32;
941 (indexLargeEnough != 0 && dictionaryInvalidated != 0) as core::ffi::c_int as u32
942}
943#[inline]
944unsafe fn ZSTD_window_needOverflowCorrection(
945 window: ZSTD_window_t,
946 cycleLog: u32,
947 maxDist: u32,
948 loadedDictEnd: u32,
949 src: *const core::ffi::c_void,
950 srcEnd: *const core::ffi::c_void,
951) -> u32 {
952 let curr = (srcEnd as *const u8).offset_from(window.base) as core::ffi::c_long as u32;
953 if ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY != 0 {
954 if ZSTD_window_canOverflowCorrect(window, cycleLog, maxDist, loadedDictEnd, src) != 0 {
955 return 1;
956 }
957 }
958 (curr
959 > (if MEM_64bits() != 0 {
960 (3500 as core::ffi::c_uint)
961 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
962 } else {
963 (2000 as core::ffi::c_uint)
964 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
965 })) as core::ffi::c_int as u32
966}
967#[inline]
968unsafe fn ZSTD_window_correctOverflow(
969 window: *mut ZSTD_window_t,
970 cycleLog: u32,
971 maxDist: u32,
972 src: *const core::ffi::c_void,
973) -> u32 {
974 let cycleSize = (1 as core::ffi::c_uint) << cycleLog;
975 let cycleMask = cycleSize.wrapping_sub(1);
976 let curr = (src as *const u8).offset_from((*window).base) as core::ffi::c_long as u32;
977 let currentCycle = curr & cycleMask;
978 let currentCycleCorrection = if currentCycle < ZSTD_WINDOW_START_INDEX as u32 {
979 if cycleSize > 2 {
980 cycleSize
981 } else {
982 2
983 }
984 } else {
985 0
986 };
987 let newCurrent = currentCycle
988 .wrapping_add(currentCycleCorrection)
989 .wrapping_add(if maxDist > cycleSize {
990 maxDist
991 } else {
992 cycleSize
993 });
994 let correction = curr.wrapping_sub(newCurrent);
995 if ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY == 0 {
996 assert!(correction > 1 << 28);
998 }
999 (*window).base = ((*window).base).offset(correction as isize);
1000 (*window).dictBase = ((*window).dictBase).offset(correction as isize);
1001 if (*window).lowLimit < correction.wrapping_add(ZSTD_WINDOW_START_INDEX as u32) {
1002 (*window).lowLimit = ZSTD_WINDOW_START_INDEX as u32;
1003 } else {
1004 (*window).lowLimit = ((*window).lowLimit).wrapping_sub(correction);
1005 }
1006 if (*window).dictLimit < correction.wrapping_add(ZSTD_WINDOW_START_INDEX as u32) {
1007 (*window).dictLimit = ZSTD_WINDOW_START_INDEX as u32;
1008 } else {
1009 (*window).dictLimit = ((*window).dictLimit).wrapping_sub(correction);
1010 }
1011 (*window).nbOverflowCorrections = ((*window).nbOverflowCorrections).wrapping_add(1);
1012 (*window).nbOverflowCorrections;
1013 correction
1014}
1015#[inline]
1016unsafe fn ZSTD_window_enforceMaxDist(
1017 window: *mut ZSTD_window_t,
1018 blockEnd: *const core::ffi::c_void,
1019 maxDist: u32,
1020 loadedDictEndPtr: *mut u32,
1021 dictMatchStatePtr: *mut *const ZSTD_MatchState_t,
1022) {
1023 let blockEndIdx =
1024 (blockEnd as *const u8).offset_from((*window).base) as core::ffi::c_long as u32;
1025 let loadedDictEnd = if !loadedDictEndPtr.is_null() {
1026 *loadedDictEndPtr
1027 } else {
1028 0
1029 };
1030 if blockEndIdx > maxDist.wrapping_add(loadedDictEnd) {
1031 let newLowLimit = blockEndIdx.wrapping_sub(maxDist);
1032 if (*window).lowLimit < newLowLimit {
1033 (*window).lowLimit = newLowLimit;
1034 }
1035 if (*window).dictLimit < (*window).lowLimit {
1036 (*window).dictLimit = (*window).lowLimit;
1037 }
1038 if !loadedDictEndPtr.is_null() {
1039 *loadedDictEndPtr = 0;
1040 }
1041 if !dictMatchStatePtr.is_null() {
1042 *dictMatchStatePtr = core::ptr::null();
1043 }
1044 }
1045}
1046#[inline]
1047unsafe fn ZSTD_checkDictValidity(
1048 window: *const ZSTD_window_t,
1049 blockEnd: *const core::ffi::c_void,
1050 maxDist: u32,
1051 loadedDictEndPtr: *mut u32,
1052 dictMatchStatePtr: *mut *const ZSTD_MatchState_t,
1053) {
1054 let blockEndIdx =
1055 (blockEnd as *const u8).offset_from((*window).base) as core::ffi::c_long as u32;
1056 let loadedDictEnd = *loadedDictEndPtr;
1057 if blockEndIdx > loadedDictEnd.wrapping_add(maxDist) || loadedDictEnd != (*window).dictLimit {
1058 *loadedDictEndPtr = 0;
1059 *dictMatchStatePtr = core::ptr::null();
1060 } else {
1061 *loadedDictEndPtr != 0;
1062 };
1063}
1064#[inline]
1065unsafe fn ZSTD_window_init(window: *mut ZSTD_window_t) {
1066 ptr::write_bytes(
1067 window as *mut u8,
1068 0,
1069 ::core::mem::size_of::<ZSTD_window_t>(),
1070 );
1071 (*window).base = b" \0" as *const u8 as *const core::ffi::c_char as *const u8;
1072 (*window).dictBase = b" \0" as *const u8 as *const core::ffi::c_char as *const u8;
1073 (*window).dictLimit = ZSTD_WINDOW_START_INDEX as u32;
1074 (*window).lowLimit = ZSTD_WINDOW_START_INDEX as u32;
1075 (*window).nextSrc = ((*window).base).offset(ZSTD_WINDOW_START_INDEX as isize);
1076 (*window).nbOverflowCorrections = 0;
1077}
1078#[inline]
1079unsafe fn ZSTD_window_update(
1080 window: *mut ZSTD_window_t,
1081 src: *const core::ffi::c_void,
1082 srcSize: size_t,
1083 forceNonContiguous: core::ffi::c_int,
1084) -> u32 {
1085 let ip = src as *const u8;
1086 let mut contiguous = 1;
1087 if srcSize == 0 {
1088 return contiguous;
1089 }
1090 if src != (*window).nextSrc as *const core::ffi::c_void || forceNonContiguous != 0 {
1091 let distanceFromBase = ((*window).nextSrc).offset_from((*window).base) as size_t;
1092 (*window).lowLimit = (*window).dictLimit;
1093 (*window).dictLimit = distanceFromBase as u32;
1094 (*window).dictBase = (*window).base;
1095 (*window).base = ip.offset(-(distanceFromBase as isize));
1096 if ((*window).dictLimit).wrapping_sub((*window).lowLimit) < HASH_READ_SIZE as u32 {
1097 (*window).lowLimit = (*window).dictLimit;
1098 }
1099 contiguous = 0;
1100 }
1101 (*window).nextSrc = ip.add(srcSize);
1102 if (ip.add(srcSize) > ((*window).dictBase).offset((*window).lowLimit as isize))
1103 as core::ffi::c_int
1104 & (ip < ((*window).dictBase).offset((*window).dictLimit as isize)) as core::ffi::c_int
1105 != 0
1106 {
1107 let highInputIdx = ip.add(srcSize).offset_from((*window).dictBase) as size_t;
1108 let lowLimitMax = if highInputIdx > (*window).dictLimit as size_t {
1109 (*window).dictLimit
1110 } else {
1111 highInputIdx as u32
1112 };
1113 (*window).lowLimit = lowLimitMax;
1114 }
1115 contiguous
1116}
1117pub const ZSTD_SHORT_CACHE_TAG_BITS: core::ffi::c_int = 8;
1118#[inline]
1119unsafe fn ZSTD_hasExtSeqProd(params: *const ZSTD_CCtx_params) -> core::ffi::c_int {
1120 ((*params).extSeqProdFunc).is_some() as core::ffi::c_int
1121}
1122
1123use libc::{calloc, free, malloc, ptrdiff_t, size_t};
1124
1125use crate::lib::common::entropy_common::FSE_readNCount;
1126use crate::lib::common::error_private::{ERR_isError, Error};
1127use crate::lib::common::fse::{
1128 FSE_CTable, FSE_repeat, FSE_repeat_check, FSE_repeat_none, FSE_repeat_valid,
1129};
1130use crate::lib::common::huf::{
1131 HUF_CElt, HUF_flags_optimalDepth, HUF_repeat, HUF_repeat_check, HUF_repeat_none,
1132 HUF_repeat_valid, HUF_OPTIMAL_DEPTH_THRESHOLD, HUF_SYMBOLVALUE_MAX, HUF_WORKSPACE_SIZE,
1133};
1134use crate::lib::common::mem::{
1135 MEM_32bits, MEM_64bits, MEM_isLittleEndian, MEM_read16, MEM_read32, MEM_read64, MEM_readLE32,
1136 MEM_readST, MEM_writeLE16, MEM_writeLE24, MEM_writeLE32, MEM_writeLE64,
1137};
1138use crate::lib::common::pool::ZSTD_threadPool;
1139use crate::lib::common::xxhash::{
1140 XXH64_state_t, ZSTD_XXH64_digest, ZSTD_XXH64_reset, ZSTD_XXH64_update,
1141};
1142use crate::lib::common::zstd_internal::{
1143 bt_compressed, bt_raw, bt_rle, repStartValue, DefaultMaxOff, LLFSELog, LL_bits, LL_defaultNorm,
1144 LL_defaultNormLog, LitHufLog, Litbits, MLFSELog, ML_bits, ML_defaultNorm, ML_defaultNormLog,
1145 MaxLL, MaxML, MaxOff, OF_defaultNorm, OF_defaultNormLog, OffFSELog, Overlap, ZSTD_copy16,
1146 ZSTD_cpuSupportsBmi2, ZSTD_limitCopy, ZSTD_wildcopy, MINMATCH, WILDCOPY_OVERLENGTH,
1147 ZSTD_OPT_NUM, ZSTD_REP_NUM, ZSTD_WORKSPACETOOLARGE_FACTOR, ZSTD_WORKSPACETOOLARGE_MAXDURATION,
1148};
1149use crate::lib::common::zstd_trace::{
1150 ZSTD_Trace, ZSTD_TraceCtx, ZSTD_trace_compress_begin, ZSTD_trace_compress_end,
1151};
1152use crate::lib::compress::fse_compress::FSE_buildCTable_wksp;
1153use crate::lib::compress::hist::{HIST_countFast_wksp, HIST_count_wksp};
1154use crate::lib::compress::huf_compress::{
1155 HUF_buildCTable_wksp, HUF_estimateCompressedSize, HUF_optimalTableLog, HUF_readCTable,
1156 HUF_validateCTable, HUF_writeCTable_wksp,
1157};
1158use crate::lib::compress::zstd_compress_literals::ZSTD_compressLiterals;
1159use crate::lib::compress::zstd_compress_sequences::{
1160 ZSTD_buildCTable, ZSTD_crossEntropyCost, ZSTD_encodeSequences, ZSTD_fseBitCost,
1161 ZSTD_selectEncodingType,
1162};
1163use crate::lib::compress::zstd_compress_superblock::ZSTD_compressSuperBlock;
1164use crate::lib::compress::zstd_double_fast::{
1165 ZSTD_compressBlock_doubleFast, ZSTD_compressBlock_doubleFast_dictMatchState,
1166 ZSTD_compressBlock_doubleFast_extDict, ZSTD_fillDoubleHashTable,
1167};
1168use crate::lib::compress::zstd_fast::{
1169 ZSTD_compressBlock_fast, ZSTD_compressBlock_fast_dictMatchState,
1170 ZSTD_compressBlock_fast_extDict, ZSTD_fillHashTable,
1171};
1172use crate::lib::compress::zstd_lazy::{
1173 ZSTD_compressBlock_btlazy2, ZSTD_compressBlock_btlazy2_dictMatchState,
1174 ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_greedy,
1175 ZSTD_compressBlock_greedy_dedicatedDictSearch,
1176 ZSTD_compressBlock_greedy_dedicatedDictSearch_row, ZSTD_compressBlock_greedy_dictMatchState,
1177 ZSTD_compressBlock_greedy_dictMatchState_row, ZSTD_compressBlock_greedy_extDict,
1178 ZSTD_compressBlock_greedy_extDict_row, ZSTD_compressBlock_greedy_row, ZSTD_compressBlock_lazy,
1179 ZSTD_compressBlock_lazy2, ZSTD_compressBlock_lazy2_dedicatedDictSearch,
1180 ZSTD_compressBlock_lazy2_dedicatedDictSearch_row, ZSTD_compressBlock_lazy2_dictMatchState,
1181 ZSTD_compressBlock_lazy2_dictMatchState_row, ZSTD_compressBlock_lazy2_extDict,
1182 ZSTD_compressBlock_lazy2_extDict_row, ZSTD_compressBlock_lazy2_row,
1183 ZSTD_compressBlock_lazy_dedicatedDictSearch, ZSTD_compressBlock_lazy_dedicatedDictSearch_row,
1184 ZSTD_compressBlock_lazy_dictMatchState, ZSTD_compressBlock_lazy_dictMatchState_row,
1185 ZSTD_compressBlock_lazy_extDict, ZSTD_compressBlock_lazy_extDict_row,
1186 ZSTD_compressBlock_lazy_row, ZSTD_dedicatedDictSearch_lazy_loadDictionary,
1187 ZSTD_insertAndFindFirstIndex, ZSTD_row_update,
1188};
1189use crate::lib::compress::zstd_ldm::{
1190 ldmEntry_t, ldmMatchCandidate_t, ldmParams_t, ldmState_t, ZSTD_ldm_adjustParameters,
1191 ZSTD_ldm_blockCompress, ZSTD_ldm_fillHashTable, ZSTD_ldm_generateSequences,
1192 ZSTD_ldm_getMaxNbSeq, ZSTD_ldm_getTableSize, ZSTD_ldm_skipRawSeqStoreBytes,
1193 ZSTD_ldm_skipSequences,
1194};
1195use crate::lib::compress::zstd_opt::{
1196 ZSTD_compressBlock_btopt, ZSTD_compressBlock_btopt_dictMatchState,
1197 ZSTD_compressBlock_btopt_extDict, ZSTD_compressBlock_btultra, ZSTD_compressBlock_btultra2,
1198 ZSTD_compressBlock_btultra_dictMatchState, ZSTD_compressBlock_btultra_extDict, ZSTD_updateTree,
1199};
1200use crate::lib::compress::zstd_preSplit::ZSTD_splitBlock;
1201use crate::lib::compress::zstdmt_compress::{
1202 ZSTDMT_CCtx, ZSTDMT_compressStream_generic, ZSTDMT_createCCtx_advanced, ZSTDMT_freeCCtx,
1203 ZSTDMT_getFrameProgression, ZSTDMT_initCStream_internal, ZSTDMT_nextInputSizeHint,
1204 ZSTDMT_sizeof_CCtx, ZSTDMT_toFlushNow, ZSTDMT_updateCParams_whileCompressing,
1205};
1206use crate::lib::zstd::*;
1207pub const ZSTD_WINDOWLOG_ABSOLUTEMIN: core::ffi::c_int = 10;
1208pub const ZSTD_BLOCKHEADERSIZE: core::ffi::c_int = 3;
1209static ZSTD_blockHeaderSize: size_t = ZSTD_BLOCKHEADERSIZE as size_t;
1210pub const MIN_CBLOCK_SIZE: core::ffi::c_int = 1 + 1;
1211pub const LONGNBSEQ: core::ffi::c_int = 0x7f00 as core::ffi::c_int;
1212pub const ZSTD_CWKSP_ALIGNMENT_BYTES: core::ffi::c_int = 64;
1213#[inline]
1214unsafe fn ZSTD_cwksp_assert_internal_consistency(ws: *mut ZSTD_cwksp) {}
1215#[inline]
1216unsafe fn ZSTD_cwksp_align(size: size_t, align: size_t) -> size_t {
1217 let mask = align.wrapping_sub(1);
1218 size.wrapping_add(mask) & !mask
1219}
1220#[inline]
1221unsafe fn ZSTD_cwksp_alloc_size(size: size_t) -> size_t {
1222 if size == 0 {
1223 return 0;
1224 }
1225 size
1226}
1227#[inline]
1228unsafe fn ZSTD_cwksp_aligned_alloc_size(size: size_t, alignment: size_t) -> size_t {
1229 ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(size, alignment))
1230}
1231#[inline]
1232unsafe fn ZSTD_cwksp_aligned64_alloc_size(size: size_t) -> size_t {
1233 ZSTD_cwksp_aligned_alloc_size(size, ZSTD_CWKSP_ALIGNMENT_BYTES as size_t)
1234}
1235#[inline]
1236unsafe fn ZSTD_cwksp_slack_space_required() -> size_t {
1237 (ZSTD_CWKSP_ALIGNMENT_BYTES * 2) as size_t
1238}
1239#[inline]
1240unsafe fn ZSTD_cwksp_bytes_to_align_ptr(ptr: *mut core::ffi::c_void, alignBytes: size_t) -> size_t {
1241 let alignBytesMask = alignBytes.wrapping_sub(1);
1242
1243 alignBytes.wrapping_sub(ptr as size_t & alignBytesMask) & alignBytesMask
1244}
1245#[inline]
1246unsafe fn ZSTD_cwksp_initialAllocStart(ws: *mut ZSTD_cwksp) -> *mut core::ffi::c_void {
1247 let mut endPtr = (*ws).workspaceEnd as *mut core::ffi::c_char;
1248 endPtr = endPtr.offset(-((endPtr as size_t % ZSTD_CWKSP_ALIGNMENT_BYTES as size_t) as isize));
1249 endPtr as *mut core::ffi::c_void
1250}
1251#[inline]
1252unsafe fn ZSTD_cwksp_reserve_internal_buffer_space(
1253 ws: *mut ZSTD_cwksp,
1254 bytes: size_t,
1255) -> *mut core::ffi::c_void {
1256 let alloc = ((*ws).allocStart as *mut u8).offset(-(bytes as isize)) as *mut core::ffi::c_void;
1257 let bottom = (*ws).tableEnd;
1258 ZSTD_cwksp_assert_internal_consistency(ws);
1259 if alloc < bottom {
1260 (*ws).allocFailed = 1;
1261 return core::ptr::null_mut();
1262 }
1263 if alloc < (*ws).tableValidEnd {
1264 (*ws).tableValidEnd = alloc;
1265 }
1266 (*ws).allocStart = alloc;
1267 alloc
1268}
1269#[inline]
1270unsafe fn ZSTD_cwksp_internal_advance_phase(
1271 ws: *mut ZSTD_cwksp,
1272 phase: ZSTD_cwksp_alloc_phase_e,
1273) -> size_t {
1274 if phase as core::ffi::c_uint > (*ws).phase as core::ffi::c_uint {
1275 if ((*ws).phase as core::ffi::c_uint)
1276 < ZSTD_cwksp_alloc_aligned_init_once as core::ffi::c_int as core::ffi::c_uint
1277 && phase as core::ffi::c_uint
1278 >= ZSTD_cwksp_alloc_aligned_init_once as core::ffi::c_int as core::ffi::c_uint
1279 {
1280 (*ws).tableValidEnd = (*ws).objectEnd;
1281 (*ws).initOnceStart = ZSTD_cwksp_initialAllocStart(ws);
1282 let alloc = (*ws).objectEnd;
1283 let bytesToAlign =
1284 ZSTD_cwksp_bytes_to_align_ptr(alloc, ZSTD_CWKSP_ALIGNMENT_BYTES as size_t);
1285 let objectEnd = (alloc as *mut u8).add(bytesToAlign) as *mut core::ffi::c_void;
1286 if objectEnd > (*ws).workspaceEnd {
1287 return Error::memory_allocation.to_error_code();
1288 }
1289 (*ws).objectEnd = objectEnd;
1290 (*ws).tableEnd = objectEnd;
1291 if (*ws).tableValidEnd < (*ws).tableEnd {
1292 (*ws).tableValidEnd = (*ws).tableEnd;
1293 }
1294 }
1295 (*ws).phase = phase;
1296 ZSTD_cwksp_assert_internal_consistency(ws);
1297 }
1298 0
1299}
1300#[inline]
1301unsafe fn ZSTD_cwksp_owns_buffer(
1302 ws: *const ZSTD_cwksp,
1303 ptr: *const core::ffi::c_void,
1304) -> core::ffi::c_int {
1305 (!ptr.is_null()
1306 && (*ws).workspace <= ptr as *mut core::ffi::c_void
1307 && ptr < (*ws).workspaceEnd as *const core::ffi::c_void) as core::ffi::c_int
1308}
1309#[inline]
1310unsafe fn ZSTD_cwksp_reserve_internal(
1311 ws: *mut ZSTD_cwksp,
1312 bytes: size_t,
1313 phase: ZSTD_cwksp_alloc_phase_e,
1314) -> *mut core::ffi::c_void {
1315 let mut alloc = core::ptr::null_mut::<core::ffi::c_void>();
1316 if ERR_isError(ZSTD_cwksp_internal_advance_phase(ws, phase)) || bytes == 0 {
1317 return core::ptr::null_mut();
1318 }
1319 alloc = ZSTD_cwksp_reserve_internal_buffer_space(ws, bytes);
1320 alloc
1321}
1322#[inline]
1323unsafe fn ZSTD_cwksp_reserve_buffer(ws: *mut ZSTD_cwksp, bytes: size_t) -> *mut u8 {
1324 ZSTD_cwksp_reserve_internal(ws, bytes, ZSTD_cwksp_alloc_buffers) as *mut u8
1325}
1326#[inline]
1327unsafe fn ZSTD_cwksp_reserve_aligned_init_once(
1328 ws: *mut ZSTD_cwksp,
1329 bytes: size_t,
1330) -> *mut core::ffi::c_void {
1331 let alignedBytes = ZSTD_cwksp_align(bytes, ZSTD_CWKSP_ALIGNMENT_BYTES as size_t);
1332 let ptr = ZSTD_cwksp_reserve_internal(ws, alignedBytes, ZSTD_cwksp_alloc_aligned_init_once);
1333 if !ptr.is_null() && ptr < (*ws).initOnceStart {
1334 ptr::write_bytes(
1335 ptr as *mut u8,
1336 0,
1337 (if (((*ws).initOnceStart as *mut u8).offset_from(ptr as *mut u8) as core::ffi::c_long
1338 as size_t)
1339 < alignedBytes
1340 {
1341 ((*ws).initOnceStart as *mut u8).offset_from(ptr as *mut u8) as core::ffi::c_long
1342 as size_t
1343 } else {
1344 alignedBytes
1345 }) as libc::size_t,
1346 );
1347 (*ws).initOnceStart = ptr;
1348 }
1349 ptr
1350}
1351#[inline]
1352unsafe fn ZSTD_cwksp_reserve_aligned64(
1353 ws: *mut ZSTD_cwksp,
1354 bytes: size_t,
1355) -> *mut core::ffi::c_void {
1356 ZSTD_cwksp_reserve_internal(
1357 ws,
1358 ZSTD_cwksp_align(bytes, ZSTD_CWKSP_ALIGNMENT_BYTES as size_t),
1359 ZSTD_cwksp_alloc_aligned,
1360 )
1361}
1362#[inline]
1363unsafe fn ZSTD_cwksp_reserve_table(ws: *mut ZSTD_cwksp, bytes: size_t) -> *mut core::ffi::c_void {
1364 let phase = ZSTD_cwksp_alloc_aligned_init_once;
1365 let mut alloc = core::ptr::null_mut::<core::ffi::c_void>();
1366 let mut end = core::ptr::null_mut::<core::ffi::c_void>();
1367 let mut top = core::ptr::null_mut::<core::ffi::c_void>();
1368 if ((*ws).phase as core::ffi::c_uint) < phase as core::ffi::c_uint
1369 && ERR_isError(ZSTD_cwksp_internal_advance_phase(ws, phase))
1370 {
1371 return core::ptr::null_mut();
1372 }
1373 alloc = (*ws).tableEnd;
1374 end = (alloc as *mut u8).add(bytes) as *mut core::ffi::c_void;
1375 top = (*ws).allocStart;
1376 ZSTD_cwksp_assert_internal_consistency(ws);
1377 if end > top {
1378 (*ws).allocFailed = 1;
1379 return core::ptr::null_mut();
1380 }
1381 (*ws).tableEnd = end;
1382 alloc
1383}
1384#[inline]
1385unsafe fn ZSTD_cwksp_reserve_object(ws: *mut ZSTD_cwksp, bytes: size_t) -> *mut core::ffi::c_void {
1386 let roundedBytes = ZSTD_cwksp_align(bytes, ::core::mem::size_of::<*mut core::ffi::c_void>());
1387 let alloc = (*ws).objectEnd;
1388 let end = (alloc as *mut u8).add(roundedBytes) as *mut core::ffi::c_void;
1389 ZSTD_cwksp_assert_internal_consistency(ws);
1390 if (*ws).phase as core::ffi::c_uint
1391 != ZSTD_cwksp_alloc_objects as core::ffi::c_int as core::ffi::c_uint
1392 || end > (*ws).workspaceEnd
1393 {
1394 (*ws).allocFailed = 1;
1395 return core::ptr::null_mut();
1396 }
1397 (*ws).objectEnd = end;
1398 (*ws).tableEnd = end;
1399 (*ws).tableValidEnd = end;
1400 alloc
1401}
1402#[inline]
1403unsafe fn ZSTD_cwksp_mark_tables_dirty(ws: *mut ZSTD_cwksp) {
1404 (*ws).tableValidEnd = (*ws).objectEnd;
1405 ZSTD_cwksp_assert_internal_consistency(ws);
1406}
1407#[inline]
1408unsafe fn ZSTD_cwksp_mark_tables_clean(ws: *mut ZSTD_cwksp) {
1409 if (*ws).tableValidEnd < (*ws).tableEnd {
1410 (*ws).tableValidEnd = (*ws).tableEnd;
1411 }
1412 ZSTD_cwksp_assert_internal_consistency(ws);
1413}
1414#[inline]
1415unsafe fn ZSTD_cwksp_clean_tables(ws: *mut ZSTD_cwksp) {
1416 if (*ws).tableValidEnd < (*ws).tableEnd {
1417 ptr::write_bytes(
1418 (*ws).tableValidEnd,
1419 0,
1420 ((*ws).tableEnd as *mut u8).offset_from((*ws).tableValidEnd as *mut u8) as usize,
1421 );
1422 }
1423 ZSTD_cwksp_mark_tables_clean(ws);
1424}
1425#[inline]
1426unsafe fn ZSTD_cwksp_clear_tables(ws: *mut ZSTD_cwksp) {
1427 (*ws).tableEnd = (*ws).objectEnd;
1428 ZSTD_cwksp_assert_internal_consistency(ws);
1429}
1430#[inline]
1431unsafe fn ZSTD_cwksp_clear(ws: *mut ZSTD_cwksp) {
1432 (*ws).tableEnd = (*ws).objectEnd;
1433 (*ws).allocStart = ZSTD_cwksp_initialAllocStart(ws);
1434 (*ws).allocFailed = 0;
1435 if (*ws).phase as core::ffi::c_uint
1436 > ZSTD_cwksp_alloc_aligned_init_once as core::ffi::c_int as core::ffi::c_uint
1437 {
1438 (*ws).phase = ZSTD_cwksp_alloc_aligned_init_once;
1439 }
1440 ZSTD_cwksp_assert_internal_consistency(ws);
1441}
1442#[inline]
1443unsafe fn ZSTD_cwksp_sizeof(ws: *const ZSTD_cwksp) -> size_t {
1444 ((*ws).workspaceEnd as *mut u8).offset_from((*ws).workspace as *mut u8) as core::ffi::c_long
1445 as size_t
1446}
1447#[inline]
1448unsafe fn ZSTD_cwksp_init(
1449 ws: *mut ZSTD_cwksp,
1450 start: *mut core::ffi::c_void,
1451 size: size_t,
1452 isStatic: ZSTD_cwksp_static_alloc_e,
1453) {
1454 (*ws).workspace = start;
1455 (*ws).workspaceEnd = (start as *mut u8).add(size) as *mut core::ffi::c_void;
1456 (*ws).objectEnd = (*ws).workspace;
1457 (*ws).tableValidEnd = (*ws).objectEnd;
1458 (*ws).initOnceStart = ZSTD_cwksp_initialAllocStart(ws);
1459 (*ws).phase = ZSTD_cwksp_alloc_objects;
1460 (*ws).isStatic = isStatic;
1461 ZSTD_cwksp_clear(ws);
1462 (*ws).workspaceOversizedDuration = 0;
1463 ZSTD_cwksp_assert_internal_consistency(ws);
1464}
1465#[inline]
1466unsafe fn ZSTD_cwksp_create(
1467 ws: *mut ZSTD_cwksp,
1468 size: size_t,
1469 customMem: ZSTD_customMem,
1470) -> size_t {
1471 let workspace = ZSTD_customMalloc(size, customMem);
1472 if workspace.is_null() {
1473 return Error::memory_allocation.to_error_code();
1474 }
1475 ZSTD_cwksp_init(ws, workspace, size, ZSTD_cwksp_dynamic_alloc);
1476 0
1477}
1478#[inline]
1479unsafe fn ZSTD_cwksp_free(ws: *mut ZSTD_cwksp, customMem: ZSTD_customMem) {
1480 let ptr = (*ws).workspace;
1481 ptr::write_bytes(ws as *mut u8, 0, ::core::mem::size_of::<ZSTD_cwksp>());
1482 ZSTD_customFree(ptr, customMem);
1483}
1484#[inline]
1485unsafe fn ZSTD_cwksp_move(dst: *mut ZSTD_cwksp, src: *mut ZSTD_cwksp) {
1486 *dst = *src;
1487 ptr::write_bytes(src as *mut u8, 0, ::core::mem::size_of::<ZSTD_cwksp>());
1488}
1489#[inline]
1490unsafe fn ZSTD_cwksp_reserve_failed(ws: *const ZSTD_cwksp) -> core::ffi::c_int {
1491 (*ws).allocFailed as core::ffi::c_int
1492}
1493#[inline]
1494unsafe fn ZSTD_cwksp_available_space(ws: *mut ZSTD_cwksp) -> size_t {
1495 ((*ws).allocStart as *mut u8).offset_from((*ws).tableEnd as *mut u8) as core::ffi::c_long
1496 as size_t
1497}
1498#[inline]
1499unsafe fn ZSTD_cwksp_check_available(
1500 ws: *mut ZSTD_cwksp,
1501 additionalNeededSpace: size_t,
1502) -> core::ffi::c_int {
1503 (ZSTD_cwksp_available_space(ws) >= additionalNeededSpace) as core::ffi::c_int
1504}
1505#[inline]
1506unsafe fn ZSTD_cwksp_check_too_large(
1507 ws: *mut ZSTD_cwksp,
1508 additionalNeededSpace: size_t,
1509) -> core::ffi::c_int {
1510 ZSTD_cwksp_check_available(
1511 ws,
1512 additionalNeededSpace * ZSTD_WORKSPACETOOLARGE_FACTOR as size_t,
1513 )
1514}
1515#[inline]
1516unsafe fn ZSTD_cwksp_check_wasteful(
1517 ws: *mut ZSTD_cwksp,
1518 additionalNeededSpace: size_t,
1519) -> core::ffi::c_int {
1520 (ZSTD_cwksp_check_too_large(ws, additionalNeededSpace) != 0
1521 && (*ws).workspaceOversizedDuration > ZSTD_WORKSPACETOOLARGE_MAXDURATION)
1522 as core::ffi::c_int
1523}
1524#[inline]
1525unsafe fn ZSTD_cwksp_bump_oversized_duration(ws: *mut ZSTD_cwksp, additionalNeededSpace: size_t) {
1526 if ZSTD_cwksp_check_too_large(ws, additionalNeededSpace) != 0 {
1527 (*ws).workspaceOversizedDuration += 1;
1528 (*ws).workspaceOversizedDuration;
1529 } else {
1530 (*ws).workspaceOversizedDuration = 0;
1531 };
1532}
1533pub const ZSTDMT_JOBSIZE_MIN: core::ffi::c_int = 512 * ((1) << 10);
1534#[inline]
1535unsafe fn ZSTD_customMalloc(size: size_t, customMem: ZSTD_customMem) -> *mut core::ffi::c_void {
1536 if (customMem.customAlloc).is_some() {
1537 return (customMem.customAlloc).unwrap_unchecked()(customMem.opaque, size);
1538 }
1539 malloc(size)
1540}
1541#[inline]
1542unsafe fn ZSTD_customCalloc(size: size_t, customMem: ZSTD_customMem) -> *mut core::ffi::c_void {
1543 if (customMem.customAlloc).is_some() {
1544 let ptr = (customMem.customAlloc).unwrap_unchecked()(customMem.opaque, size);
1545 ptr::write_bytes(ptr, 0, size);
1546 return ptr;
1547 }
1548 calloc(1, size)
1549}
1550#[inline]
1551unsafe fn ZSTD_customFree(ptr: *mut core::ffi::c_void, customMem: ZSTD_customMem) {
1552 if !ptr.is_null() {
1553 if (customMem.customFree).is_some() {
1554 (customMem.customFree).unwrap_unchecked()(customMem.opaque, ptr);
1555 } else {
1556 free(ptr);
1557 }
1558 }
1559}
1560#[inline]
1561unsafe fn ZSTD_countTrailingZeros32(val: u32) -> core::ffi::c_uint {
1562 val.trailing_zeros() as i32 as core::ffi::c_uint
1563}
1564#[inline]
1565unsafe fn ZSTD_countLeadingZeros32(val: u32) -> core::ffi::c_uint {
1566 val.leading_zeros() as i32 as core::ffi::c_uint
1567}
1568#[inline]
1569unsafe fn ZSTD_countTrailingZeros64(val: u64) -> core::ffi::c_uint {
1570 (val as core::ffi::c_ulonglong).trailing_zeros() as i32 as core::ffi::c_uint
1571}
1572#[inline]
1573unsafe fn ZSTD_countLeadingZeros64(val: u64) -> core::ffi::c_uint {
1574 (val as core::ffi::c_ulonglong).leading_zeros() as i32 as core::ffi::c_uint
1575}
1576#[inline]
1577unsafe fn ZSTD_NbCommonBytes(val: size_t) -> core::ffi::c_uint {
1578 if MEM_isLittleEndian() != 0 {
1579 if MEM_64bits() != 0 {
1580 ZSTD_countTrailingZeros64(val as u64) >> 3
1581 } else {
1582 ZSTD_countTrailingZeros32(val as u32) >> 3
1583 }
1584 } else if MEM_64bits() != 0 {
1585 ZSTD_countLeadingZeros64(val as u64) >> 3
1586 } else {
1587 ZSTD_countLeadingZeros32(val as u32) >> 3
1588 }
1589}
1590#[inline]
1591unsafe fn ZSTD_highbit32(val: u32) -> core::ffi::c_uint {
1592 (31 as core::ffi::c_uint).wrapping_sub(ZSTD_countLeadingZeros32(val))
1593}
1594#[inline]
1595unsafe fn ZSTD_rotateRight_U64(value: u64, mut count: u32) -> u64 {
1596 count &= 0x3f;
1597 value >> count | value << ((0 as core::ffi::c_uint).wrapping_sub(count) & 0x3f)
1598}
1599pub const STREAM_ACCUMULATOR_MIN_32: core::ffi::c_int = 25;
1600pub const STREAM_ACCUMULATOR_MIN_64: core::ffi::c_int = 57;
1601pub const ZSTD_COMPRESSBLOCK_DOUBLEFAST: unsafe fn(
1602 *mut ZSTD_MatchState_t,
1603 *mut SeqStore_t,
1604 *mut u32,
1605 *const core::ffi::c_void,
1606 size_t,
1607) -> size_t = ZSTD_compressBlock_doubleFast;
1608pub const ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE: unsafe fn(
1609 *mut ZSTD_MatchState_t,
1610 *mut SeqStore_t,
1611 *mut u32,
1612 *const core::ffi::c_void,
1613 size_t,
1614) -> size_t = ZSTD_compressBlock_doubleFast_dictMatchState;
1615pub const ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT: unsafe fn(
1616 *mut ZSTD_MatchState_t,
1617 *mut SeqStore_t,
1618 *mut u32,
1619 *const core::ffi::c_void,
1620 size_t,
1621) -> size_t = ZSTD_compressBlock_doubleFast_extDict;
1622pub const ZSTD_LAZY_DDSS_BUCKET_LOG: core::ffi::c_int = 2;
1623pub const ZSTD_ROW_HASH_TAG_BITS: core::ffi::c_int = 8;
1624pub const ZSTD_COMPRESSBLOCK_GREEDY: unsafe fn(
1625 *mut ZSTD_MatchState_t,
1626 *mut SeqStore_t,
1627 *mut u32,
1628 *const core::ffi::c_void,
1629 size_t,
1630) -> size_t = ZSTD_compressBlock_greedy;
1631pub const ZSTD_COMPRESSBLOCK_GREEDY_ROW: unsafe fn(
1632 *mut ZSTD_MatchState_t,
1633 *mut SeqStore_t,
1634 *mut u32,
1635 *const core::ffi::c_void,
1636 size_t,
1637) -> size_t = ZSTD_compressBlock_greedy_row;
1638pub const ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE: unsafe fn(
1639 *mut ZSTD_MatchState_t,
1640 *mut SeqStore_t,
1641 *mut u32,
1642 *const core::ffi::c_void,
1643 size_t,
1644) -> size_t = ZSTD_compressBlock_greedy_dictMatchState;
1645pub const ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW: unsafe fn(
1646 *mut ZSTD_MatchState_t,
1647 *mut SeqStore_t,
1648 *mut u32,
1649 *const core::ffi::c_void,
1650 size_t,
1651) -> size_t = ZSTD_compressBlock_greedy_dictMatchState_row;
1652pub const ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH: unsafe fn(
1653 *mut ZSTD_MatchState_t,
1654 *mut SeqStore_t,
1655 *mut u32,
1656 *const core::ffi::c_void,
1657 size_t,
1658) -> size_t = ZSTD_compressBlock_greedy_dedicatedDictSearch;
1659pub const ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW: unsafe fn(
1660 *mut ZSTD_MatchState_t,
1661 *mut SeqStore_t,
1662 *mut u32,
1663 *const core::ffi::c_void,
1664 size_t,
1665) -> size_t = ZSTD_compressBlock_greedy_dedicatedDictSearch_row;
1666pub const ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT: unsafe fn(
1667 *mut ZSTD_MatchState_t,
1668 *mut SeqStore_t,
1669 *mut u32,
1670 *const core::ffi::c_void,
1671 size_t,
1672) -> size_t = ZSTD_compressBlock_greedy_extDict;
1673pub const ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW: unsafe fn(
1674 *mut ZSTD_MatchState_t,
1675 *mut SeqStore_t,
1676 *mut u32,
1677 *const core::ffi::c_void,
1678 size_t,
1679) -> size_t = ZSTD_compressBlock_greedy_extDict_row;
1680pub const ZSTD_COMPRESSBLOCK_LAZY: unsafe fn(
1681 *mut ZSTD_MatchState_t,
1682 *mut SeqStore_t,
1683 *mut u32,
1684 *const core::ffi::c_void,
1685 size_t,
1686) -> size_t = ZSTD_compressBlock_lazy;
1687pub const ZSTD_COMPRESSBLOCK_LAZY_ROW: unsafe fn(
1688 *mut ZSTD_MatchState_t,
1689 *mut SeqStore_t,
1690 *mut u32,
1691 *const core::ffi::c_void,
1692 size_t,
1693) -> size_t = ZSTD_compressBlock_lazy_row;
1694pub const ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE: unsafe fn(
1695 *mut ZSTD_MatchState_t,
1696 *mut SeqStore_t,
1697 *mut u32,
1698 *const core::ffi::c_void,
1699 size_t,
1700) -> size_t = ZSTD_compressBlock_lazy_dictMatchState;
1701pub const ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW: unsafe fn(
1702 *mut ZSTD_MatchState_t,
1703 *mut SeqStore_t,
1704 *mut u32,
1705 *const core::ffi::c_void,
1706 size_t,
1707) -> size_t = ZSTD_compressBlock_lazy_dictMatchState_row;
1708pub const ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH: unsafe fn(
1709 *mut ZSTD_MatchState_t,
1710 *mut SeqStore_t,
1711 *mut u32,
1712 *const core::ffi::c_void,
1713 size_t,
1714) -> size_t = ZSTD_compressBlock_lazy_dedicatedDictSearch;
1715pub const ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW: unsafe fn(
1716 *mut ZSTD_MatchState_t,
1717 *mut SeqStore_t,
1718 *mut u32,
1719 *const core::ffi::c_void,
1720 size_t,
1721) -> size_t = ZSTD_compressBlock_lazy_dedicatedDictSearch_row;
1722pub const ZSTD_COMPRESSBLOCK_LAZY_EXTDICT: unsafe fn(
1723 *mut ZSTD_MatchState_t,
1724 *mut SeqStore_t,
1725 *mut u32,
1726 *const core::ffi::c_void,
1727 size_t,
1728) -> size_t = ZSTD_compressBlock_lazy_extDict;
1729pub const ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW: unsafe fn(
1730 *mut ZSTD_MatchState_t,
1731 *mut SeqStore_t,
1732 *mut u32,
1733 *const core::ffi::c_void,
1734 size_t,
1735) -> size_t = ZSTD_compressBlock_lazy_extDict_row;
1736pub const ZSTD_COMPRESSBLOCK_LAZY2: unsafe fn(
1737 *mut ZSTD_MatchState_t,
1738 *mut SeqStore_t,
1739 *mut u32,
1740 *const core::ffi::c_void,
1741 size_t,
1742) -> size_t = ZSTD_compressBlock_lazy2;
1743pub const ZSTD_COMPRESSBLOCK_LAZY2_ROW: unsafe fn(
1744 *mut ZSTD_MatchState_t,
1745 *mut SeqStore_t,
1746 *mut u32,
1747 *const core::ffi::c_void,
1748 size_t,
1749) -> size_t = ZSTD_compressBlock_lazy2_row;
1750pub const ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE: unsafe fn(
1751 *mut ZSTD_MatchState_t,
1752 *mut SeqStore_t,
1753 *mut u32,
1754 *const core::ffi::c_void,
1755 size_t,
1756) -> size_t = ZSTD_compressBlock_lazy2_dictMatchState;
1757pub const ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW: unsafe fn(
1758 *mut ZSTD_MatchState_t,
1759 *mut SeqStore_t,
1760 *mut u32,
1761 *const core::ffi::c_void,
1762 size_t,
1763) -> size_t = ZSTD_compressBlock_lazy2_dictMatchState_row;
1764pub const ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH: unsafe fn(
1765 *mut ZSTD_MatchState_t,
1766 *mut SeqStore_t,
1767 *mut u32,
1768 *const core::ffi::c_void,
1769 size_t,
1770) -> size_t = ZSTD_compressBlock_lazy2_dedicatedDictSearch;
1771pub const ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW: unsafe fn(
1772 *mut ZSTD_MatchState_t,
1773 *mut SeqStore_t,
1774 *mut u32,
1775 *const core::ffi::c_void,
1776 size_t,
1777) -> size_t = ZSTD_compressBlock_lazy2_dedicatedDictSearch_row;
1778pub const ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT: unsafe fn(
1779 *mut ZSTD_MatchState_t,
1780 *mut SeqStore_t,
1781 *mut u32,
1782 *const core::ffi::c_void,
1783 size_t,
1784) -> size_t = ZSTD_compressBlock_lazy2_extDict;
1785pub const ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW: unsafe fn(
1786 *mut ZSTD_MatchState_t,
1787 *mut SeqStore_t,
1788 *mut u32,
1789 *const core::ffi::c_void,
1790 size_t,
1791) -> size_t = ZSTD_compressBlock_lazy2_extDict_row;
1792pub const ZSTD_COMPRESSBLOCK_BTLAZY2: unsafe fn(
1793 *mut ZSTD_MatchState_t,
1794 *mut SeqStore_t,
1795 *mut u32,
1796 *const core::ffi::c_void,
1797 size_t,
1798) -> size_t = ZSTD_compressBlock_btlazy2;
1799pub const ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE: unsafe fn(
1800 *mut ZSTD_MatchState_t,
1801 *mut SeqStore_t,
1802 *mut u32,
1803 *const core::ffi::c_void,
1804 size_t,
1805) -> size_t = ZSTD_compressBlock_btlazy2_dictMatchState;
1806pub const ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT: unsafe fn(
1807 *mut ZSTD_MatchState_t,
1808 *mut SeqStore_t,
1809 *mut u32,
1810 *const core::ffi::c_void,
1811 size_t,
1812) -> size_t = ZSTD_compressBlock_btlazy2_extDict;
1813pub const ZSTD_COMPRESSBLOCK_BTOPT: unsafe fn(
1814 *mut ZSTD_MatchState_t,
1815 *mut SeqStore_t,
1816 *mut u32,
1817 *const core::ffi::c_void,
1818 size_t,
1819) -> size_t = ZSTD_compressBlock_btopt;
1820pub const ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE: unsafe fn(
1821 *mut ZSTD_MatchState_t,
1822 *mut SeqStore_t,
1823 *mut u32,
1824 *const core::ffi::c_void,
1825 size_t,
1826) -> size_t = ZSTD_compressBlock_btopt_dictMatchState;
1827pub const ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT: unsafe fn(
1828 *mut ZSTD_MatchState_t,
1829 *mut SeqStore_t,
1830 *mut u32,
1831 *const core::ffi::c_void,
1832 size_t,
1833) -> size_t = ZSTD_compressBlock_btopt_extDict;
1834pub const ZSTD_COMPRESSBLOCK_BTULTRA: unsafe fn(
1835 *mut ZSTD_MatchState_t,
1836 *mut SeqStore_t,
1837 *mut u32,
1838 *const core::ffi::c_void,
1839 size_t,
1840) -> size_t = ZSTD_compressBlock_btultra;
1841pub const ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE: unsafe fn(
1842 *mut ZSTD_MatchState_t,
1843 *mut SeqStore_t,
1844 *mut u32,
1845 *const core::ffi::c_void,
1846 size_t,
1847) -> size_t = ZSTD_compressBlock_btultra_dictMatchState;
1848pub const ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT: unsafe fn(
1849 *mut ZSTD_MatchState_t,
1850 *mut SeqStore_t,
1851 *mut u32,
1852 *const core::ffi::c_void,
1853 size_t,
1854) -> size_t = ZSTD_compressBlock_btultra_extDict;
1855pub const ZSTD_COMPRESSBLOCK_BTULTRA2: unsafe fn(
1856 *mut ZSTD_MatchState_t,
1857 *mut SeqStore_t,
1858 *mut u32,
1859 *const core::ffi::c_void,
1860 size_t,
1861) -> size_t = ZSTD_compressBlock_btultra2;
1862pub const ZSTD_LDM_DEFAULT_WINDOW_LOG: core::ffi::c_int = 27;
1863pub const INT_MAX: core::ffi::c_int = __INT_MAX__;
1864#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBound))]
1865pub unsafe extern "C" fn ZSTD_compressBound(srcSize: size_t) -> size_t {
1866 let r = if srcSize as core::ffi::c_ulonglong
1867 >= (if ::core::mem::size_of::<size_t>() == 8 {
1868 0xff00ff00ff00ff00 as core::ffi::c_ulonglong
1869 } else {
1870 0xff00ff00 as core::ffi::c_uint as core::ffi::c_ulonglong
1871 }) {
1872 0
1873 } else {
1874 srcSize
1875 .wrapping_add(srcSize >> 8)
1876 .wrapping_add(if srcSize < ((128) << 10) as size_t {
1877 (((128) << 10) as size_t).wrapping_sub(srcSize) >> 11
1878 } else {
1879 0
1880 })
1881 };
1882 if r == 0 {
1883 return Error::srcSize_wrong.to_error_code();
1884 }
1885 r
1886}
1887#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCCtx))]
1888pub unsafe extern "C" fn ZSTD_createCCtx() -> *mut ZSTD_CCtx {
1889 ZSTD_createCCtx_advanced(ZSTD_defaultCMem)
1890}
1891unsafe fn ZSTD_initCCtx(cctx: *mut ZSTD_CCtx, memManager: ZSTD_customMem) {
1892 ptr::write_bytes(cctx as *mut u8, 0, ::core::mem::size_of::<ZSTD_CCtx>());
1893 (*cctx).customMem = memManager;
1894 (*cctx).bmi2 = ZSTD_cpuSupportsBmi2() as _;
1895 let err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);
1896}
1897#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCCtx_advanced))]
1898pub unsafe extern "C" fn ZSTD_createCCtx_advanced(customMem: ZSTD_customMem) -> *mut ZSTD_CCtx {
1899 if (customMem.customAlloc).is_none() as core::ffi::c_int
1900 ^ (customMem.customFree).is_none() as core::ffi::c_int
1901 != 0
1902 {
1903 return core::ptr::null_mut();
1904 }
1905 let cctx = ZSTD_customMalloc(::core::mem::size_of::<ZSTD_CCtx>(), customMem) as *mut ZSTD_CCtx;
1906 if cctx.is_null() {
1907 return core::ptr::null_mut();
1908 }
1909 ZSTD_initCCtx(cctx, customMem);
1910 cctx
1911}
1912#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initStaticCCtx))]
1913pub unsafe extern "C" fn ZSTD_initStaticCCtx(
1914 workspace: *mut core::ffi::c_void,
1915 workspaceSize: size_t,
1916) -> *mut ZSTD_CCtx {
1917 let mut ws = ZSTD_cwksp {
1918 workspace: core::ptr::null_mut::<core::ffi::c_void>(),
1919 workspaceEnd: core::ptr::null_mut::<core::ffi::c_void>(),
1920 objectEnd: core::ptr::null_mut::<core::ffi::c_void>(),
1921 tableEnd: core::ptr::null_mut::<core::ffi::c_void>(),
1922 tableValidEnd: core::ptr::null_mut::<core::ffi::c_void>(),
1923 allocStart: core::ptr::null_mut::<core::ffi::c_void>(),
1924 initOnceStart: core::ptr::null_mut::<core::ffi::c_void>(),
1925 allocFailed: 0,
1926 workspaceOversizedDuration: 0,
1927 phase: ZSTD_cwksp_alloc_objects,
1928 isStatic: ZSTD_cwksp_dynamic_alloc,
1929 };
1930 let mut cctx = core::ptr::null_mut::<ZSTD_CCtx>();
1931 if workspaceSize <= ::core::mem::size_of::<ZSTD_CCtx>() {
1932 return core::ptr::null_mut();
1933 }
1934 if workspace as size_t & 7 != 0 {
1935 return core::ptr::null_mut();
1936 }
1937 ZSTD_cwksp_init(&mut ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc);
1938 cctx =
1939 ZSTD_cwksp_reserve_object(&mut ws, ::core::mem::size_of::<ZSTD_CCtx>()) as *mut ZSTD_CCtx;
1940 if cctx.is_null() {
1941 return core::ptr::null_mut();
1942 }
1943 ptr::write_bytes(cctx as *mut u8, 0, ::core::mem::size_of::<ZSTD_CCtx>());
1944 ZSTD_cwksp_move(&mut (*cctx).workspace, &mut ws);
1945 (*cctx).staticSize = workspaceSize;
1946 if ZSTD_cwksp_check_available(
1947 &mut (*cctx).workspace,
1948 (if ((((8) << 10) + 512) as size_t).wrapping_add(
1949 (::core::mem::size_of::<core::ffi::c_uint>())
1950 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
1951 ) > 8208
1952 {
1953 ((((8) << 10) + 512) as size_t).wrapping_add(
1954 (::core::mem::size_of::<core::ffi::c_uint>())
1955 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
1956 )
1957 } else {
1958 8208
1959 })
1960 .wrapping_add(
1961 (2 as size_t).wrapping_mul(::core::mem::size_of::<ZSTD_compressedBlockState_t>()),
1962 ),
1963 ) == 0
1964 {
1965 return core::ptr::null_mut();
1966 }
1967 (*cctx).blockState.prevCBlock = ZSTD_cwksp_reserve_object(
1968 &mut (*cctx).workspace,
1969 ::core::mem::size_of::<ZSTD_compressedBlockState_t>(),
1970 ) as *mut ZSTD_compressedBlockState_t;
1971 (*cctx).blockState.nextCBlock = ZSTD_cwksp_reserve_object(
1972 &mut (*cctx).workspace,
1973 ::core::mem::size_of::<ZSTD_compressedBlockState_t>(),
1974 ) as *mut ZSTD_compressedBlockState_t;
1975 (*cctx).tmpWorkspace = ZSTD_cwksp_reserve_object(
1976 &mut (*cctx).workspace,
1977 if ((((8) << 10) + 512) as size_t).wrapping_add(
1978 (::core::mem::size_of::<core::ffi::c_uint>())
1979 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
1980 ) > 8208
1981 {
1982 ((((8) << 10) + 512) as size_t).wrapping_add(
1983 (::core::mem::size_of::<core::ffi::c_uint>())
1984 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
1985 )
1986 } else {
1987 8208
1988 },
1989 );
1990 (*cctx).tmpWkspSize = if ((((8) << 10) + 512) as size_t).wrapping_add(
1991 (::core::mem::size_of::<core::ffi::c_uint>())
1992 .wrapping_mul(((if 35 > 52 as core::ffi::c_int { 35 } else { 52 }) + 2) as size_t),
1993 ) > 8208 as size_t
1994 {
1995 ((((8) << 10) + 512) as size_t).wrapping_add(
1996 (::core::mem::size_of::<core::ffi::c_uint>())
1997 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
1998 )
1999 } else {
2000 8208
2001 };
2002 (*cctx).bmi2 = ZSTD_cpuSupportsBmi2() as _;
2003 cctx
2004}
2005unsafe fn ZSTD_clearAllDicts(cctx: *mut ZSTD_CCtx) {
2006 ZSTD_customFree((*cctx).localDict.dictBuffer, (*cctx).customMem);
2007 ZSTD_freeCDict((*cctx).localDict.cdict);
2008 ptr::write_bytes(
2009 &mut (*cctx).localDict as *mut ZSTD_localDict as *mut u8,
2010 0,
2011 ::core::mem::size_of::<ZSTD_localDict>(),
2012 );
2013 ptr::write_bytes(
2014 &mut (*cctx).prefixDict as *mut ZSTD_prefixDict as *mut u8,
2015 0,
2016 ::core::mem::size_of::<ZSTD_prefixDict>(),
2017 );
2018 (*cctx).cdict = core::ptr::null();
2019}
2020unsafe fn ZSTD_sizeof_localDict(dict: ZSTD_localDict) -> size_t {
2021 let bufferSize = if !(dict.dictBuffer).is_null() {
2022 dict.dictSize
2023 } else {
2024 0
2025 };
2026 let cdictSize = ZSTD_sizeof_CDict(dict.cdict);
2027 bufferSize.wrapping_add(cdictSize)
2028}
2029unsafe fn ZSTD_freeCCtxContent(cctx: *mut ZSTD_CCtx) {
2030 ZSTD_clearAllDicts(cctx);
2031 ZSTDMT_freeCCtx((*cctx).mtctx);
2032 (*cctx).mtctx = core::ptr::null_mut();
2033 ZSTD_cwksp_free(&mut (*cctx).workspace, (*cctx).customMem);
2034}
2035#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_freeCCtx))]
2036pub unsafe extern "C" fn ZSTD_freeCCtx(cctx: *mut ZSTD_CCtx) -> size_t {
2037 if cctx.is_null() {
2038 return 0;
2039 }
2040 if (*cctx).staticSize != 0 {
2041 return Error::memory_allocation.to_error_code();
2042 }
2043 let cctxInWorkspace =
2044 ZSTD_cwksp_owns_buffer(&(*cctx).workspace, cctx as *const core::ffi::c_void);
2045 ZSTD_freeCCtxContent(cctx);
2046 if cctxInWorkspace == 0 {
2047 ZSTD_customFree(cctx as *mut core::ffi::c_void, (*cctx).customMem);
2048 }
2049 0
2050}
2051unsafe fn ZSTD_sizeof_mtctx(cctx: *const ZSTD_CCtx) -> size_t {
2052 ZSTDMT_sizeof_CCtx((*cctx).mtctx)
2053}
2054#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_sizeof_CCtx))]
2055pub unsafe extern "C" fn ZSTD_sizeof_CCtx(cctx: *const ZSTD_CCtx) -> size_t {
2056 if cctx.is_null() {
2057 return 0;
2058 }
2059 (if (*cctx).workspace.workspace == cctx as *mut core::ffi::c_void {
2060 0
2061 } else {
2062 ::core::mem::size_of::<ZSTD_CCtx>()
2063 })
2064 .wrapping_add(ZSTD_cwksp_sizeof(&(*cctx).workspace))
2065 .wrapping_add(ZSTD_sizeof_localDict((*cctx).localDict))
2066 .wrapping_add(ZSTD_sizeof_mtctx(cctx))
2067}
2068#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_sizeof_CStream))]
2069pub unsafe extern "C" fn ZSTD_sizeof_CStream(zcs: *const ZSTD_CStream) -> size_t {
2070 ZSTD_sizeof_CCtx(zcs)
2071}
2072pub unsafe fn ZSTD_getSeqStore(ctx: *const ZSTD_CCtx) -> *const SeqStore_t {
2073 &(*ctx).seqStore
2074}
2075unsafe fn ZSTD_rowMatchFinderSupported(strategy: ZSTD_strategy) -> core::ffi::c_int {
2076 (strategy as core::ffi::c_uint >= ZSTD_greedy as core::ffi::c_int as core::ffi::c_uint
2077 && strategy as core::ffi::c_uint <= ZSTD_lazy2 as core::ffi::c_int as core::ffi::c_uint)
2078 as core::ffi::c_int
2079}
2080unsafe fn ZSTD_rowMatchFinderUsed(
2081 strategy: ZSTD_strategy,
2082 mode: ZSTD_ParamSwitch_e,
2083) -> core::ffi::c_int {
2084 (ZSTD_rowMatchFinderSupported(strategy) != 0
2085 && mode as core::ffi::c_uint == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint)
2086 as core::ffi::c_int
2087}
2088unsafe fn ZSTD_resolveRowMatchFinderMode(
2089 mut mode: ZSTD_ParamSwitch_e,
2090 cParams: *const ZSTD_compressionParameters,
2091) -> ZSTD_ParamSwitch_e {
2092 let kWindowLogLowerBound = 14;
2093 if mode as core::ffi::c_uint != ZSTD_ps_auto as core::ffi::c_int as core::ffi::c_uint {
2094 return mode;
2095 }
2096 mode = ZSTD_ps_disable;
2097 if ZSTD_rowMatchFinderSupported((*cParams).strategy) == 0 {
2098 return mode;
2099 }
2100 if (*cParams).windowLog > kWindowLogLowerBound {
2101 mode = ZSTD_ps_enable;
2102 }
2103 mode
2104}
2105unsafe fn ZSTD_resolveBlockSplitterMode(
2106 mode: ZSTD_ParamSwitch_e,
2107 cParams: *const ZSTD_compressionParameters,
2108) -> ZSTD_ParamSwitch_e {
2109 if mode as core::ffi::c_uint != ZSTD_ps_auto as core::ffi::c_int as core::ffi::c_uint {
2110 return mode;
2111 }
2112 (if (*cParams).strategy as core::ffi::c_uint
2113 >= ZSTD_btopt as core::ffi::c_int as core::ffi::c_uint
2114 && (*cParams).windowLog >= 17
2115 {
2116 ZSTD_ps_enable as core::ffi::c_int
2117 } else {
2118 ZSTD_ps_disable as core::ffi::c_int
2119 }) as ZSTD_ParamSwitch_e
2120}
2121unsafe fn ZSTD_allocateChainTable(
2122 strategy: ZSTD_strategy,
2123 useRowMatchFinder: ZSTD_ParamSwitch_e,
2124 forDDSDict: u32,
2125) -> core::ffi::c_int {
2126 (forDDSDict != 0
2127 || strategy as core::ffi::c_uint != ZSTD_fast as core::ffi::c_int as core::ffi::c_uint
2128 && ZSTD_rowMatchFinderUsed(strategy, useRowMatchFinder) == 0) as core::ffi::c_int
2129}
2130unsafe fn ZSTD_resolveEnableLdm(
2131 mode: ZSTD_ParamSwitch_e,
2132 cParams: *const ZSTD_compressionParameters,
2133) -> ZSTD_ParamSwitch_e {
2134 if mode as core::ffi::c_uint != ZSTD_ps_auto as core::ffi::c_int as core::ffi::c_uint {
2135 return mode;
2136 }
2137 (if (*cParams).strategy as core::ffi::c_uint
2138 >= ZSTD_btopt as core::ffi::c_int as core::ffi::c_uint
2139 && (*cParams).windowLog >= 27
2140 {
2141 ZSTD_ps_enable as core::ffi::c_int
2142 } else {
2143 ZSTD_ps_disable as core::ffi::c_int
2144 }) as ZSTD_ParamSwitch_e
2145}
2146unsafe fn ZSTD_resolveExternalSequenceValidation(mode: core::ffi::c_int) -> core::ffi::c_int {
2147 mode
2148}
2149unsafe fn ZSTD_resolveMaxBlockSize(maxBlockSize: size_t) -> size_t {
2150 if maxBlockSize == 0 {
2151 ZSTD_BLOCKSIZE_MAX as size_t
2152 } else {
2153 maxBlockSize
2154 }
2155}
2156unsafe fn ZSTD_resolveExternalRepcodeSearch(
2157 value: ZSTD_ParamSwitch_e,
2158 cLevel: core::ffi::c_int,
2159) -> ZSTD_ParamSwitch_e {
2160 if value as core::ffi::c_uint != ZSTD_ps_auto as core::ffi::c_int as core::ffi::c_uint {
2161 return value;
2162 }
2163 if cLevel < 10 {
2164 ZSTD_ps_disable
2165 } else {
2166 ZSTD_ps_enable
2167 }
2168}
2169unsafe fn ZSTD_CDictIndicesAreTagged(
2170 cParams: *const ZSTD_compressionParameters,
2171) -> core::ffi::c_int {
2172 ((*cParams).strategy as core::ffi::c_uint == ZSTD_fast as core::ffi::c_int as core::ffi::c_uint
2173 || (*cParams).strategy as core::ffi::c_uint
2174 == ZSTD_dfast as core::ffi::c_int as core::ffi::c_uint) as core::ffi::c_int
2175}
2176unsafe fn ZSTD_makeCCtxParamsFromCParams(cParams: ZSTD_compressionParameters) -> ZSTD_CCtx_params {
2177 let mut cctxParams = ZSTD_CCtx_params_s {
2178 format: Format::ZSTD_f_zstd1,
2179 cParams: ZSTD_compressionParameters {
2180 windowLog: 0,
2181 chainLog: 0,
2182 hashLog: 0,
2183 searchLog: 0,
2184 minMatch: 0,
2185 targetLength: 0,
2186 strategy: 0,
2187 },
2188 fParams: ZSTD_frameParameters {
2189 contentSizeFlag: 0,
2190 checksumFlag: 0,
2191 noDictIDFlag: 0,
2192 },
2193 compressionLevel: 0,
2194 forceWindow: 0,
2195 targetCBlockSize: 0,
2196 srcSizeHint: 0,
2197 attachDictPref: ZSTD_dictDefaultAttach,
2198 literalCompressionMode: ZSTD_ps_auto,
2199 nbWorkers: 0,
2200 jobSize: 0,
2201 overlapLog: 0,
2202 rsyncable: 0,
2203 ldmParams: ldmParams_t {
2204 enableLdm: ZSTD_ps_auto,
2205 hashLog: 0,
2206 bucketSizeLog: 0,
2207 minMatchLength: 0,
2208 hashRateLog: 0,
2209 windowLog: 0,
2210 },
2211 enableDedicatedDictSearch: 0,
2212 inBufferMode: ZSTD_bm_buffered,
2213 outBufferMode: ZSTD_bm_buffered,
2214 blockDelimiters: ZSTD_sf_noBlockDelimiters,
2215 validateSequences: 0,
2216 postBlockSplitter: ZSTD_ps_auto,
2217 preBlockSplitter_level: 0,
2218 maxBlockSize: 0,
2219 useRowMatchFinder: ZSTD_ps_auto,
2220 deterministicRefPrefix: 0,
2221 customMem: ZSTD_customMem {
2222 customAlloc: None,
2223 customFree: None,
2224 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
2225 },
2226 prefetchCDictTables: ZSTD_ps_auto,
2227 enableMatchFinderFallback: 0,
2228 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
2229 extSeqProdFunc: None,
2230 searchForExternalRepcodes: ZSTD_ps_auto,
2231 };
2232 ZSTD_CCtxParams_init(&mut cctxParams, ZSTD_CLEVEL_DEFAULT);
2233 cctxParams.cParams = cParams;
2234 cctxParams.ldmParams.enableLdm =
2235 ZSTD_resolveEnableLdm(cctxParams.ldmParams.enableLdm, &cParams);
2236 if cctxParams.ldmParams.enableLdm as core::ffi::c_uint
2237 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
2238 {
2239 ZSTD_ldm_adjustParameters(&mut cctxParams.ldmParams, &cParams);
2240 }
2241 cctxParams.postBlockSplitter =
2242 ZSTD_resolveBlockSplitterMode(cctxParams.postBlockSplitter, &cParams);
2243 cctxParams.useRowMatchFinder =
2244 ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);
2245 cctxParams.validateSequences =
2246 ZSTD_resolveExternalSequenceValidation(cctxParams.validateSequences);
2247 cctxParams.maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams.maxBlockSize);
2248 cctxParams.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(
2249 cctxParams.searchForExternalRepcodes,
2250 cctxParams.compressionLevel,
2251 );
2252 cctxParams
2253}
2254unsafe fn ZSTD_createCCtxParams_advanced(customMem: ZSTD_customMem) -> *mut ZSTD_CCtx_params {
2255 let mut params = core::ptr::null_mut::<ZSTD_CCtx_params>();
2256 if (customMem.customAlloc).is_none() as core::ffi::c_int
2257 ^ (customMem.customFree).is_none() as core::ffi::c_int
2258 != 0
2259 {
2260 return core::ptr::null_mut();
2261 }
2262 params = ZSTD_customCalloc(::core::mem::size_of::<ZSTD_CCtx_params>(), customMem)
2263 as *mut ZSTD_CCtx_params;
2264 if params.is_null() {
2265 return core::ptr::null_mut();
2266 }
2267 ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);
2268 (*params).customMem = customMem;
2269 params
2270}
2271#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCCtxParams))]
2272pub unsafe extern "C" fn ZSTD_createCCtxParams() -> *mut ZSTD_CCtx_params {
2273 ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem)
2274}
2275#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_freeCCtxParams))]
2276pub unsafe extern "C" fn ZSTD_freeCCtxParams(params: *mut ZSTD_CCtx_params) -> size_t {
2277 if params.is_null() {
2278 return 0;
2279 }
2280 ZSTD_customFree(params as *mut core::ffi::c_void, (*params).customMem);
2281 0
2282}
2283#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtxParams_reset))]
2284pub unsafe extern "C" fn ZSTD_CCtxParams_reset(params: *mut ZSTD_CCtx_params) -> size_t {
2285 ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT)
2286}
2287#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtxParams_init))]
2288pub unsafe extern "C" fn ZSTD_CCtxParams_init(
2289 cctxParams: *mut ZSTD_CCtx_params,
2290 compressionLevel: core::ffi::c_int,
2291) -> size_t {
2292 if cctxParams.is_null() {
2293 return Error::GENERIC.to_error_code();
2294 }
2295 ptr::write_bytes(
2296 cctxParams as *mut u8,
2297 0,
2298 ::core::mem::size_of::<ZSTD_CCtx_params>(),
2299 );
2300 (*cctxParams).compressionLevel = compressionLevel;
2301 (*cctxParams).fParams.contentSizeFlag = 1;
2302 0
2303}
2304pub const ZSTD_NO_CLEVEL: core::ffi::c_int = 0;
2305unsafe fn ZSTD_CCtxParams_init_internal(
2306 cctxParams: *mut ZSTD_CCtx_params,
2307 params: *const ZSTD_parameters,
2308 compressionLevel: core::ffi::c_int,
2309) {
2310 ptr::write_bytes(
2311 cctxParams as *mut u8,
2312 0,
2313 ::core::mem::size_of::<ZSTD_CCtx_params>(),
2314 );
2315 (*cctxParams).cParams = (*params).cParams;
2316 (*cctxParams).fParams = (*params).fParams;
2317 (*cctxParams).compressionLevel = compressionLevel;
2318 (*cctxParams).useRowMatchFinder =
2319 ZSTD_resolveRowMatchFinderMode((*cctxParams).useRowMatchFinder, &(*params).cParams);
2320 (*cctxParams).postBlockSplitter =
2321 ZSTD_resolveBlockSplitterMode((*cctxParams).postBlockSplitter, &(*params).cParams);
2322 (*cctxParams).ldmParams.enableLdm =
2323 ZSTD_resolveEnableLdm((*cctxParams).ldmParams.enableLdm, &(*params).cParams);
2324 (*cctxParams).validateSequences =
2325 ZSTD_resolveExternalSequenceValidation((*cctxParams).validateSequences);
2326 (*cctxParams).maxBlockSize = ZSTD_resolveMaxBlockSize((*cctxParams).maxBlockSize);
2327 (*cctxParams).searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(
2328 (*cctxParams).searchForExternalRepcodes,
2329 compressionLevel,
2330 );
2331}
2332#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtxParams_init_advanced))]
2333pub unsafe extern "C" fn ZSTD_CCtxParams_init_advanced(
2334 cctxParams: *mut ZSTD_CCtx_params,
2335 params: ZSTD_parameters,
2336) -> size_t {
2337 if cctxParams.is_null() {
2338 return Error::GENERIC.to_error_code();
2339 }
2340 let err_code = ZSTD_checkCParams(params.cParams);
2341 if ERR_isError(err_code) {
2342 return err_code;
2343 }
2344 ZSTD_CCtxParams_init_internal(cctxParams, ¶ms, ZSTD_NO_CLEVEL);
2345 0
2346}
2347unsafe fn ZSTD_CCtxParams_setZstdParams(
2348 cctxParams: *mut ZSTD_CCtx_params,
2349 params: *const ZSTD_parameters,
2350) {
2351 (*cctxParams).cParams = (*params).cParams;
2352 (*cctxParams).fParams = (*params).fParams;
2353 (*cctxParams).compressionLevel = ZSTD_NO_CLEVEL;
2354}
2355#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_cParam_getBounds))]
2356pub unsafe extern "C" fn ZSTD_cParam_getBounds(param: ZSTD_cParameter) -> ZSTD_bounds {
2357 let mut bounds = {
2358 ZSTD_bounds {
2359 error: 0,
2360 lowerBound: 0,
2361 upperBound: 0,
2362 }
2363 };
2364 match param as core::ffi::c_uint {
2365 100 => {
2366 bounds.lowerBound = ZSTD_minCLevel();
2367 bounds.upperBound = ZSTD_maxCLevel();
2368 bounds
2369 }
2370 101 => {
2371 bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
2372 bounds.upperBound = if ::core::mem::size_of::<size_t>() == 4 {
2373 ZSTD_WINDOWLOG_MAX_32
2374 } else {
2375 ZSTD_WINDOWLOG_MAX_64
2376 };
2377 bounds
2378 }
2379 102 => {
2380 bounds.lowerBound = ZSTD_HASHLOG_MIN;
2381 bounds.upperBound = if (if ::core::mem::size_of::<size_t>() == 4 {
2382 ZSTD_WINDOWLOG_MAX_32
2383 } else {
2384 ZSTD_WINDOWLOG_MAX_64
2385 }) < 30
2386 {
2387 if ::core::mem::size_of::<size_t>() == 4 {
2388 ZSTD_WINDOWLOG_MAX_32
2389 } else {
2390 ZSTD_WINDOWLOG_MAX_64
2391 }
2392 } else {
2393 30
2394 };
2395 bounds
2396 }
2397 103 => {
2398 bounds.lowerBound = ZSTD_CHAINLOG_MIN;
2399 bounds.upperBound = if ::core::mem::size_of::<size_t>() == 4 {
2400 ZSTD_CHAINLOG_MAX_32
2401 } else {
2402 ZSTD_CHAINLOG_MAX_64
2403 };
2404 bounds
2405 }
2406 104 => {
2407 bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
2408 bounds.upperBound = (if ::core::mem::size_of::<size_t>() == 4 {
2409 ZSTD_WINDOWLOG_MAX_32
2410 } else {
2411 ZSTD_WINDOWLOG_MAX_64
2412 }) - 1;
2413 bounds
2414 }
2415 105 => {
2416 bounds.lowerBound = ZSTD_MINMATCH_MIN;
2417 bounds.upperBound = ZSTD_MINMATCH_MAX;
2418 bounds
2419 }
2420 106 => {
2421 bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
2422 bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
2423 bounds
2424 }
2425 107 => {
2426 bounds.lowerBound = ZSTD_STRATEGY_MIN;
2427 bounds.upperBound = ZSTD_STRATEGY_MAX;
2428 bounds
2429 }
2430 200 => {
2431 bounds.lowerBound = 0;
2432 bounds.upperBound = 1;
2433 bounds
2434 }
2435 201 => {
2436 bounds.lowerBound = 0;
2437 bounds.upperBound = 1;
2438 bounds
2439 }
2440 202 => {
2441 bounds.lowerBound = 0;
2442 bounds.upperBound = 1;
2443 bounds
2444 }
2445 400 => {
2446 bounds.lowerBound = 0;
2447 bounds.upperBound = if ::core::mem::size_of::<*mut core::ffi::c_void>() == 4 {
2448 64
2449 } else {
2450 256
2451 };
2452 bounds
2453 }
2454 401 => {
2455 bounds.lowerBound = 0;
2456 bounds.upperBound = if MEM_32bits() != 0 {
2457 512 * ((1) << 20)
2458 } else {
2459 1024 * ((1) << 20)
2460 };
2461 bounds
2462 }
2463 402 => {
2464 bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;
2465 bounds.upperBound = ZSTD_OVERLAPLOG_MAX;
2466 bounds
2467 }
2468 1005 => {
2469 bounds.lowerBound = 0;
2470 bounds.upperBound = 1;
2471 bounds
2472 }
2473 160 => {
2474 bounds.lowerBound = ZSTD_ps_auto as core::ffi::c_int;
2475 bounds.upperBound = ZSTD_ps_disable as core::ffi::c_int;
2476 bounds
2477 }
2478 161 => {
2479 bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;
2480 bounds.upperBound = if (if ::core::mem::size_of::<size_t>() == 4 {
2481 ZSTD_WINDOWLOG_MAX_32
2482 } else {
2483 ZSTD_WINDOWLOG_MAX_64
2484 }) < 30
2485 {
2486 if ::core::mem::size_of::<size_t>() == 4 {
2487 ZSTD_WINDOWLOG_MAX_32
2488 } else {
2489 ZSTD_WINDOWLOG_MAX_64
2490 }
2491 } else {
2492 30
2493 };
2494 bounds
2495 }
2496 162 => {
2497 bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;
2498 bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;
2499 bounds
2500 }
2501 163 => {
2502 bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;
2503 bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;
2504 bounds
2505 }
2506 164 => {
2507 bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;
2508 bounds.upperBound = (if ::core::mem::size_of::<size_t>() == 4 {
2509 ZSTD_WINDOWLOG_MAX_32
2510 } else {
2511 ZSTD_WINDOWLOG_MAX_64
2512 }) - ZSTD_HASHLOG_MIN;
2513 bounds
2514 }
2515 500 => {
2516 bounds.lowerBound = 0;
2517 bounds.upperBound = 1;
2518 bounds
2519 }
2520 1000 => {
2521 bounds.lowerBound = 0;
2522 bounds.upperBound = 1;
2523 bounds
2524 }
2525 10 => {
2526 bounds.lowerBound = Format::ZSTD_f_zstd1 as core::ffi::c_int;
2527 bounds.upperBound = Format::ZSTD_f_zstd1_magicless as core::ffi::c_int;
2528 bounds
2529 }
2530 1001 => {
2531 bounds.lowerBound = ZSTD_dictDefaultAttach as core::ffi::c_int;
2532 bounds.upperBound = ZSTD_dictForceLoad as core::ffi::c_int;
2533 bounds
2534 }
2535 1002 => {
2536 bounds.lowerBound = ZSTD_ps_auto as core::ffi::c_int;
2537 bounds.upperBound = ZSTD_ps_disable as core::ffi::c_int;
2538 bounds
2539 }
2540 130 => {
2541 bounds.lowerBound = ZSTD_TARGETCBLOCKSIZE_MIN;
2542 bounds.upperBound = ZSTD_TARGETCBLOCKSIZE_MAX;
2543 bounds
2544 }
2545 1004 => {
2546 bounds.lowerBound = ZSTD_SRCSIZEHINT_MIN;
2547 bounds.upperBound = ZSTD_SRCSIZEHINT_MAX;
2548 bounds
2549 }
2550 1006 | 1007 => {
2551 bounds.lowerBound = ZSTD_bm_buffered as core::ffi::c_int;
2552 bounds.upperBound = ZSTD_bm_stable as core::ffi::c_int;
2553 bounds
2554 }
2555 1008 => {
2556 bounds.lowerBound = ZSTD_sf_noBlockDelimiters as core::ffi::c_int;
2557 bounds.upperBound = ZSTD_sf_explicitBlockDelimiters as core::ffi::c_int;
2558 bounds
2559 }
2560 1009 => {
2561 bounds.lowerBound = 0;
2562 bounds.upperBound = 1;
2563 bounds
2564 }
2565 1010 => {
2566 bounds.lowerBound = ZSTD_ps_auto as core::ffi::c_int;
2567 bounds.upperBound = ZSTD_ps_disable as core::ffi::c_int;
2568 bounds
2569 }
2570 1017 => {
2571 bounds.lowerBound = 0;
2572 bounds.upperBound = ZSTD_BLOCKSPLITTER_LEVEL_MAX;
2573 bounds
2574 }
2575 1011 => {
2576 bounds.lowerBound = ZSTD_ps_auto as core::ffi::c_int;
2577 bounds.upperBound = ZSTD_ps_disable as core::ffi::c_int;
2578 bounds
2579 }
2580 1012 => {
2581 bounds.lowerBound = 0;
2582 bounds.upperBound = 1;
2583 bounds
2584 }
2585 1013 => {
2586 bounds.lowerBound = ZSTD_ps_auto as core::ffi::c_int;
2587 bounds.upperBound = ZSTD_ps_disable as core::ffi::c_int;
2588 bounds
2589 }
2590 1014 => {
2591 bounds.lowerBound = 0;
2592 bounds.upperBound = 1;
2593 bounds
2594 }
2595 1015 => {
2596 bounds.lowerBound = ZSTD_BLOCKSIZE_MAX_MIN;
2597 bounds.upperBound = ZSTD_BLOCKSIZE_MAX;
2598 bounds
2599 }
2600 1016 => {
2601 bounds.lowerBound = ZSTD_ps_auto as core::ffi::c_int;
2602 bounds.upperBound = ZSTD_ps_disable as core::ffi::c_int;
2603 bounds
2604 }
2605 _ => {
2606 bounds.error = Error::parameter_unsupported.to_error_code();
2607 bounds
2608 }
2609 }
2610}
2611unsafe fn ZSTD_cParam_clampBounds(cParam: ZSTD_cParameter, value: *mut core::ffi::c_int) -> size_t {
2612 let bounds = ZSTD_cParam_getBounds(cParam);
2613 if ERR_isError(bounds.error) {
2614 return bounds.error;
2615 }
2616 if *value < bounds.lowerBound {
2617 *value = bounds.lowerBound;
2618 }
2619 if *value > bounds.upperBound {
2620 *value = bounds.upperBound;
2621 }
2622 0
2623}
2624unsafe fn ZSTD_isUpdateAuthorized(param: ZSTD_cParameter) -> core::ffi::c_int {
2625 match param as core::ffi::c_uint {
2626 100 | 102 | 103 | 104 | 105 | 106 | 107 | 1017 => 1,
2627 10 | 101 | 200 | 201 | 202 | 1000 | 400 | 401 | 402 | 500 | 1005 | 160 | 161 | 162
2628 | 163 | 164 | 1001 | 1002 | 130 | 1004 | 1006 | 1007 | 1008 | 1009 | 1010 | 1011 | 1012
2629 | 1013 | 1014 | 1015 | 1016 | _ => 0,
2630 }
2631}
2632#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_setParameter))]
2633pub unsafe extern "C" fn ZSTD_CCtx_setParameter(
2634 cctx: *mut ZSTD_CCtx,
2635 param: ZSTD_cParameter,
2636 value: core::ffi::c_int,
2637) -> size_t {
2638 if (*cctx).streamStage as core::ffi::c_uint
2639 != zcss_init as core::ffi::c_int as core::ffi::c_uint
2640 {
2641 if ZSTD_isUpdateAuthorized(param) != 0 {
2642 (*cctx).cParamsChanged = 1;
2643 } else {
2644 return Error::stage_wrong.to_error_code();
2645 }
2646 }
2647 match param as core::ffi::c_uint {
2648 400 => {
2649 if value != 0 && (*cctx).staticSize != 0 {
2650 return Error::parameter_unsupported.to_error_code();
2651 }
2652 }
2653 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 164 | 10 | 200 | 201 | 202 | 1000
2654 | 1001 | 1002 | 401 | 402 | 500 | 1005 | 160 | 161 | 162 | 163 | 130 | 1004 | 1006
2655 | 1007 | 1008 | 1009 | 1010 | 1017 | 1011 | 1012 | 1013 | 1014 | 1015 | 1016 => {}
2656 _ => return Error::parameter_unsupported.to_error_code(),
2657 }
2658 ZSTD_CCtxParams_setParameter(&mut (*cctx).requestedParams, param, value)
2659}
2660#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtxParams_setParameter))]
2661pub unsafe extern "C" fn ZSTD_CCtxParams_setParameter(
2662 CCtxParams: *mut ZSTD_CCtx_params,
2663 param: ZSTD_cParameter,
2664 mut value: core::ffi::c_int,
2665) -> size_t {
2666 match param as core::ffi::c_uint {
2667 10 => {
2668 let Ok(format) = Format::try_from(value as ZSTD_format_e) else {
2669 return Error::parameter_outOfBound.to_error_code();
2670 };
2671
2672 (*CCtxParams).format = format;
2673 (*CCtxParams).format as size_t
2674 }
2675 100 => {
2676 let err_code = ZSTD_cParam_clampBounds(param, &mut value);
2677 if ERR_isError(err_code) {
2678 return err_code;
2679 }
2680 if value == 0 {
2681 (*CCtxParams).compressionLevel = ZSTD_CLEVEL_DEFAULT;
2682 } else {
2683 (*CCtxParams).compressionLevel = value;
2684 }
2685 if (*CCtxParams).compressionLevel >= 0 {
2686 return (*CCtxParams).compressionLevel as size_t;
2687 }
2688 0
2689 }
2690 101 => {
2691 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_windowLog, value) == 0 {
2692 return Error::parameter_outOfBound.to_error_code();
2693 }
2694 (*CCtxParams).cParams.windowLog = value as u32;
2695 (*CCtxParams).cParams.windowLog as size_t
2696 }
2697 102 => {
2698 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_hashLog, value) == 0 {
2699 return Error::parameter_outOfBound.to_error_code();
2700 }
2701 (*CCtxParams).cParams.hashLog = value as u32;
2702 (*CCtxParams).cParams.hashLog as size_t
2703 }
2704 103 => {
2705 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_chainLog, value) == 0 {
2706 return Error::parameter_outOfBound.to_error_code();
2707 }
2708 (*CCtxParams).cParams.chainLog = value as u32;
2709 (*CCtxParams).cParams.chainLog as size_t
2710 }
2711 104 => {
2712 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_searchLog, value) == 0 {
2713 return Error::parameter_outOfBound.to_error_code();
2714 }
2715 (*CCtxParams).cParams.searchLog = value as u32;
2716 value as size_t
2717 }
2718 105 => {
2719 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_minMatch, value) == 0 {
2720 return Error::parameter_outOfBound.to_error_code();
2721 }
2722 (*CCtxParams).cParams.minMatch = value as u32;
2723 (*CCtxParams).cParams.minMatch as size_t
2724 }
2725 106 => {
2726 if ZSTD_cParam_withinBounds(ZSTD_c_targetLength, value) == 0 {
2727 return Error::parameter_outOfBound.to_error_code();
2728 }
2729 (*CCtxParams).cParams.targetLength = value as u32;
2730 (*CCtxParams).cParams.targetLength as size_t
2731 }
2732 107 => {
2733 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_strategy, value) == 0 {
2734 return Error::parameter_outOfBound.to_error_code();
2735 }
2736 (*CCtxParams).cParams.strategy = value as ZSTD_strategy;
2737 (*CCtxParams).cParams.strategy as size_t
2738 }
2739 200 => {
2740 (*CCtxParams).fParams.contentSizeFlag = (value != 0) as core::ffi::c_int;
2741 (*CCtxParams).fParams.contentSizeFlag as size_t
2742 }
2743 201 => {
2744 (*CCtxParams).fParams.checksumFlag = (value != 0) as core::ffi::c_int;
2745 (*CCtxParams).fParams.checksumFlag as size_t
2746 }
2747 202 => {
2748 (*CCtxParams).fParams.noDictIDFlag = (value == 0) as core::ffi::c_int;
2749 ((*CCtxParams).fParams.noDictIDFlag == 0) as core::ffi::c_int as size_t
2750 }
2751 1000 => {
2752 (*CCtxParams).forceWindow = (value != 0) as core::ffi::c_int;
2753 (*CCtxParams).forceWindow as size_t
2754 }
2755 1001 => {
2756 let pref = value as ZSTD_dictAttachPref_e;
2757 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam4, pref as core::ffi::c_int) == 0 {
2758 return Error::parameter_outOfBound.to_error_code();
2759 }
2760 (*CCtxParams).attachDictPref = pref;
2761 (*CCtxParams).attachDictPref as size_t
2762 }
2763 1002 => {
2764 let lcm = value as ZSTD_ParamSwitch_e;
2765 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam5, lcm as core::ffi::c_int) == 0 {
2766 return Error::parameter_outOfBound.to_error_code();
2767 }
2768 (*CCtxParams).literalCompressionMode = lcm;
2769 (*CCtxParams).literalCompressionMode as size_t
2770 }
2771 400 => {
2772 let err_code_0 = ZSTD_cParam_clampBounds(param, &mut value);
2773 if ERR_isError(err_code_0) {
2774 return err_code_0;
2775 }
2776 (*CCtxParams).nbWorkers = value;
2777 (*CCtxParams).nbWorkers as size_t
2778 }
2779 401 => {
2780 if value != 0 && value < ZSTDMT_JOBSIZE_MIN {
2781 value = ZSTDMT_JOBSIZE_MIN;
2782 }
2783 let err_code_1 = ZSTD_cParam_clampBounds(param, &mut value);
2784 if ERR_isError(err_code_1) {
2785 return err_code_1;
2786 }
2787 (*CCtxParams).jobSize = value as size_t;
2788 (*CCtxParams).jobSize
2789 }
2790 402 => {
2791 let err_code_2 = ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &mut value);
2792 if ERR_isError(err_code_2) {
2793 return err_code_2;
2794 }
2795 (*CCtxParams).overlapLog = value;
2796 (*CCtxParams).overlapLog as size_t
2797 }
2798 500 => {
2799 let err_code_3 = ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &mut value);
2800 if ERR_isError(err_code_3) {
2801 return err_code_3;
2802 }
2803 (*CCtxParams).rsyncable = value;
2804 (*CCtxParams).rsyncable as size_t
2805 }
2806 1005 => {
2807 (*CCtxParams).enableDedicatedDictSearch = (value != 0) as core::ffi::c_int;
2808 (*CCtxParams).enableDedicatedDictSearch as size_t
2809 }
2810 160 => {
2811 if ZSTD_cParam_withinBounds(ZSTD_c_enableLongDistanceMatching, value) == 0 {
2812 return Error::parameter_outOfBound.to_error_code();
2813 }
2814 (*CCtxParams).ldmParams.enableLdm = value as ZSTD_ParamSwitch_e;
2815 (*CCtxParams).ldmParams.enableLdm as size_t
2816 }
2817 161 => {
2818 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_ldmHashLog, value) == 0 {
2819 return Error::parameter_outOfBound.to_error_code();
2820 }
2821 (*CCtxParams).ldmParams.hashLog = value as u32;
2822 (*CCtxParams).ldmParams.hashLog as size_t
2823 }
2824 162 => {
2825 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_ldmMinMatch, value) == 0 {
2826 return Error::parameter_outOfBound.to_error_code();
2827 }
2828 (*CCtxParams).ldmParams.minMatchLength = value as u32;
2829 (*CCtxParams).ldmParams.minMatchLength as size_t
2830 }
2831 163 => {
2832 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_ldmBucketSizeLog, value) == 0 {
2833 return Error::parameter_outOfBound.to_error_code();
2834 }
2835 (*CCtxParams).ldmParams.bucketSizeLog = value as u32;
2836 (*CCtxParams).ldmParams.bucketSizeLog as size_t
2837 }
2838 164 => {
2839 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_ldmHashRateLog, value) == 0 {
2840 return Error::parameter_outOfBound.to_error_code();
2841 }
2842 (*CCtxParams).ldmParams.hashRateLog = value as u32;
2843 (*CCtxParams).ldmParams.hashRateLog as size_t
2844 }
2845 130 => {
2846 if value != 0 {
2847 value = if value > 1340 { value } else { 1340 };
2848 if ZSTD_cParam_withinBounds(ZSTD_c_targetCBlockSize, value) == 0 {
2849 return Error::parameter_outOfBound.to_error_code();
2850 }
2851 }
2852 (*CCtxParams).targetCBlockSize = value as u32 as size_t;
2853 (*CCtxParams).targetCBlockSize
2854 }
2855 1004 => {
2856 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam7, value) == 0 {
2857 return Error::parameter_outOfBound.to_error_code();
2858 }
2859 (*CCtxParams).srcSizeHint = value;
2860 (*CCtxParams).srcSizeHint as size_t
2861 }
2862 1006 => {
2863 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam9, value) == 0 {
2864 return Error::parameter_outOfBound.to_error_code();
2865 }
2866 (*CCtxParams).inBufferMode = value as ZSTD_bufferMode_e;
2867 (*CCtxParams).inBufferMode as size_t
2868 }
2869 1007 => {
2870 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam10, value) == 0 {
2871 return Error::parameter_outOfBound.to_error_code();
2872 }
2873 (*CCtxParams).outBufferMode = value as ZSTD_bufferMode_e;
2874 (*CCtxParams).outBufferMode as size_t
2875 }
2876 1008 => {
2877 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam11, value) == 0 {
2878 return Error::parameter_outOfBound.to_error_code();
2879 }
2880 (*CCtxParams).blockDelimiters = value as ZSTD_SequenceFormat_e;
2881 (*CCtxParams).blockDelimiters as size_t
2882 }
2883 1009 => {
2884 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam12, value) == 0 {
2885 return Error::parameter_outOfBound.to_error_code();
2886 }
2887 (*CCtxParams).validateSequences = value;
2888 (*CCtxParams).validateSequences as size_t
2889 }
2890 1010 => {
2891 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam13, value) == 0 {
2892 return Error::parameter_outOfBound.to_error_code();
2893 }
2894 (*CCtxParams).postBlockSplitter = value as ZSTD_ParamSwitch_e;
2895 (*CCtxParams).postBlockSplitter as size_t
2896 }
2897 1017 => {
2898 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam20, value) == 0 {
2899 return Error::parameter_outOfBound.to_error_code();
2900 }
2901 (*CCtxParams).preBlockSplitter_level = value;
2902 (*CCtxParams).preBlockSplitter_level as size_t
2903 }
2904 1011 => {
2905 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam14, value) == 0 {
2906 return Error::parameter_outOfBound.to_error_code();
2907 }
2908 (*CCtxParams).useRowMatchFinder = value as ZSTD_ParamSwitch_e;
2909 (*CCtxParams).useRowMatchFinder as size_t
2910 }
2911 1012 => {
2912 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam15, value) == 0 {
2913 return Error::parameter_outOfBound.to_error_code();
2914 }
2915 (*CCtxParams).deterministicRefPrefix = (value != 0) as core::ffi::c_int;
2916 (*CCtxParams).deterministicRefPrefix as size_t
2917 }
2918 1013 => {
2919 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam16, value) == 0 {
2920 return Error::parameter_outOfBound.to_error_code();
2921 }
2922 (*CCtxParams).prefetchCDictTables = value as ZSTD_ParamSwitch_e;
2923 (*CCtxParams).prefetchCDictTables as size_t
2924 }
2925 1014 => {
2926 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam17, value) == 0 {
2927 return Error::parameter_outOfBound.to_error_code();
2928 }
2929 (*CCtxParams).enableMatchFinderFallback = value;
2930 (*CCtxParams).enableMatchFinderFallback as size_t
2931 }
2932 1015 => {
2933 if value != 0 && ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam18, value) == 0 {
2934 return Error::parameter_outOfBound.to_error_code();
2935 }
2936 (*CCtxParams).maxBlockSize = value as size_t;
2937 (*CCtxParams).maxBlockSize
2938 }
2939 1016 => {
2940 if ZSTD_cParam_withinBounds(ZSTD_c_experimentalParam19, value) == 0 {
2941 return Error::parameter_outOfBound.to_error_code();
2942 }
2943 (*CCtxParams).searchForExternalRepcodes = value as ZSTD_ParamSwitch_e;
2944 (*CCtxParams).searchForExternalRepcodes as size_t
2945 }
2946 _ => Error::parameter_unsupported.to_error_code(),
2947 }
2948}
2949#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_getParameter))]
2950pub unsafe extern "C" fn ZSTD_CCtx_getParameter(
2951 cctx: *const ZSTD_CCtx,
2952 param: ZSTD_cParameter,
2953 value: *mut core::ffi::c_int,
2954) -> size_t {
2955 ZSTD_CCtxParams_getParameter(&(*cctx).requestedParams, param, value)
2956}
2957#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtxParams_getParameter))]
2958pub unsafe extern "C" fn ZSTD_CCtxParams_getParameter(
2959 CCtxParams: *const ZSTD_CCtx_params,
2960 param: ZSTD_cParameter,
2961 value: *mut core::ffi::c_int,
2962) -> size_t {
2963 match param as core::ffi::c_uint {
2964 10 => {
2965 *value = (*CCtxParams).format as core::ffi::c_int;
2966 }
2967 100 => {
2968 *value = (*CCtxParams).compressionLevel;
2969 }
2970 101 => {
2971 *value = (*CCtxParams).cParams.windowLog as core::ffi::c_int;
2972 }
2973 102 => {
2974 *value = (*CCtxParams).cParams.hashLog as core::ffi::c_int;
2975 }
2976 103 => {
2977 *value = (*CCtxParams).cParams.chainLog as core::ffi::c_int;
2978 }
2979 104 => {
2980 *value = (*CCtxParams).cParams.searchLog as core::ffi::c_int;
2981 }
2982 105 => {
2983 *value = (*CCtxParams).cParams.minMatch as core::ffi::c_int;
2984 }
2985 106 => {
2986 *value = (*CCtxParams).cParams.targetLength as core::ffi::c_int;
2987 }
2988 107 => {
2989 *value = (*CCtxParams).cParams.strategy as core::ffi::c_int;
2990 }
2991 200 => {
2992 *value = (*CCtxParams).fParams.contentSizeFlag;
2993 }
2994 201 => {
2995 *value = (*CCtxParams).fParams.checksumFlag;
2996 }
2997 202 => {
2998 *value = ((*CCtxParams).fParams.noDictIDFlag == 0) as core::ffi::c_int;
2999 }
3000 1000 => {
3001 *value = (*CCtxParams).forceWindow;
3002 }
3003 1001 => {
3004 *value = (*CCtxParams).attachDictPref as core::ffi::c_int;
3005 }
3006 1002 => {
3007 *value = (*CCtxParams).literalCompressionMode as core::ffi::c_int;
3008 }
3009 400 => {
3010 *value = (*CCtxParams).nbWorkers;
3011 }
3012 401 => {
3013 *value = (*CCtxParams).jobSize as core::ffi::c_int;
3014 }
3015 402 => {
3016 *value = (*CCtxParams).overlapLog;
3017 }
3018 500 => {
3019 *value = (*CCtxParams).rsyncable;
3020 }
3021 1005 => {
3022 *value = (*CCtxParams).enableDedicatedDictSearch;
3023 }
3024 160 => {
3025 *value = (*CCtxParams).ldmParams.enableLdm as core::ffi::c_int;
3026 }
3027 161 => {
3028 *value = (*CCtxParams).ldmParams.hashLog as core::ffi::c_int;
3029 }
3030 162 => {
3031 *value = (*CCtxParams).ldmParams.minMatchLength as core::ffi::c_int;
3032 }
3033 163 => {
3034 *value = (*CCtxParams).ldmParams.bucketSizeLog as core::ffi::c_int;
3035 }
3036 164 => {
3037 *value = (*CCtxParams).ldmParams.hashRateLog as core::ffi::c_int;
3038 }
3039 130 => {
3040 *value = (*CCtxParams).targetCBlockSize as core::ffi::c_int;
3041 }
3042 1004 => {
3043 *value = (*CCtxParams).srcSizeHint;
3044 }
3045 1006 => {
3046 *value = (*CCtxParams).inBufferMode as core::ffi::c_int;
3047 }
3048 1007 => {
3049 *value = (*CCtxParams).outBufferMode as core::ffi::c_int;
3050 }
3051 1008 => {
3052 *value = (*CCtxParams).blockDelimiters as core::ffi::c_int;
3053 }
3054 1009 => {
3055 *value = (*CCtxParams).validateSequences;
3056 }
3057 1010 => {
3058 *value = (*CCtxParams).postBlockSplitter as core::ffi::c_int;
3059 }
3060 1017 => {
3061 *value = (*CCtxParams).preBlockSplitter_level;
3062 }
3063 1011 => {
3064 *value = (*CCtxParams).useRowMatchFinder as core::ffi::c_int;
3065 }
3066 1012 => {
3067 *value = (*CCtxParams).deterministicRefPrefix;
3068 }
3069 1013 => {
3070 *value = (*CCtxParams).prefetchCDictTables as core::ffi::c_int;
3071 }
3072 1014 => {
3073 *value = (*CCtxParams).enableMatchFinderFallback;
3074 }
3075 1015 => {
3076 *value = (*CCtxParams).maxBlockSize as core::ffi::c_int;
3077 }
3078 1016 => {
3079 *value = (*CCtxParams).searchForExternalRepcodes as core::ffi::c_int;
3080 }
3081 _ => return Error::parameter_unsupported.to_error_code(),
3082 }
3083 0
3084}
3085#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_setParametersUsingCCtxParams))]
3086pub unsafe extern "C" fn ZSTD_CCtx_setParametersUsingCCtxParams(
3087 cctx: *mut ZSTD_CCtx,
3088 params: *const ZSTD_CCtx_params,
3089) -> size_t {
3090 if (*cctx).streamStage as core::ffi::c_uint
3091 != zcss_init as core::ffi::c_int as core::ffi::c_uint
3092 {
3093 return Error::stage_wrong.to_error_code();
3094 }
3095 if !((*cctx).cdict).is_null() {
3096 return Error::stage_wrong.to_error_code();
3097 }
3098 (*cctx).requestedParams = *params;
3099 0
3100}
3101#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_setCParams))]
3102pub unsafe extern "C" fn ZSTD_CCtx_setCParams(
3103 cctx: *mut ZSTD_CCtx,
3104 cparams: ZSTD_compressionParameters,
3105) -> size_t {
3106 let err_code = ZSTD_checkCParams(cparams);
3107 if ERR_isError(err_code) {
3108 return err_code;
3109 }
3110 let err_code_0 = ZSTD_CCtx_setParameter(
3111 cctx,
3112 ZSTD_c_windowLog,
3113 cparams.windowLog as core::ffi::c_int,
3114 );
3115 if ERR_isError(err_code_0) {
3116 return err_code_0;
3117 }
3118 let err_code_1 =
3119 ZSTD_CCtx_setParameter(cctx, ZSTD_c_chainLog, cparams.chainLog as core::ffi::c_int);
3120 if ERR_isError(err_code_1) {
3121 return err_code_1;
3122 }
3123 let err_code_2 =
3124 ZSTD_CCtx_setParameter(cctx, ZSTD_c_hashLog, cparams.hashLog as core::ffi::c_int);
3125 if ERR_isError(err_code_2) {
3126 return err_code_2;
3127 }
3128 let err_code_3 = ZSTD_CCtx_setParameter(
3129 cctx,
3130 ZSTD_c_searchLog,
3131 cparams.searchLog as core::ffi::c_int,
3132 );
3133 if ERR_isError(err_code_3) {
3134 return err_code_3;
3135 }
3136 let err_code_4 =
3137 ZSTD_CCtx_setParameter(cctx, ZSTD_c_minMatch, cparams.minMatch as core::ffi::c_int);
3138 if ERR_isError(err_code_4) {
3139 return err_code_4;
3140 }
3141 let err_code_5 = ZSTD_CCtx_setParameter(
3142 cctx,
3143 ZSTD_c_targetLength,
3144 cparams.targetLength as core::ffi::c_int,
3145 );
3146 if ERR_isError(err_code_5) {
3147 return err_code_5;
3148 }
3149 let err_code_6 =
3150 ZSTD_CCtx_setParameter(cctx, ZSTD_c_strategy, cparams.strategy as core::ffi::c_int);
3151 if ERR_isError(err_code_6) {
3152 return err_code_6;
3153 }
3154 0
3155}
3156#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_setFParams))]
3157pub unsafe extern "C" fn ZSTD_CCtx_setFParams(
3158 cctx: *mut ZSTD_CCtx,
3159 fparams: ZSTD_frameParameters,
3160) -> size_t {
3161 let err_code = ZSTD_CCtx_setParameter(
3162 cctx,
3163 ZSTD_c_contentSizeFlag,
3164 (fparams.contentSizeFlag != 0) as core::ffi::c_int,
3165 );
3166 if ERR_isError(err_code) {
3167 return err_code;
3168 }
3169 let err_code_0 = ZSTD_CCtx_setParameter(
3170 cctx,
3171 ZSTD_c_checksumFlag,
3172 (fparams.checksumFlag != 0) as core::ffi::c_int,
3173 );
3174 if ERR_isError(err_code_0) {
3175 return err_code_0;
3176 }
3177 let err_code_1 = ZSTD_CCtx_setParameter(
3178 cctx,
3179 ZSTD_c_dictIDFlag,
3180 (fparams.noDictIDFlag == 0) as core::ffi::c_int,
3181 );
3182 if ERR_isError(err_code_1) {
3183 return err_code_1;
3184 }
3185 0
3186}
3187#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_setParams))]
3188pub unsafe extern "C" fn ZSTD_CCtx_setParams(
3189 cctx: *mut ZSTD_CCtx,
3190 params: ZSTD_parameters,
3191) -> size_t {
3192 let err_code = ZSTD_checkCParams(params.cParams);
3193 if ERR_isError(err_code) {
3194 return err_code;
3195 }
3196 let err_code_0 = ZSTD_CCtx_setFParams(cctx, params.fParams);
3197 if ERR_isError(err_code_0) {
3198 return err_code_0;
3199 }
3200 let err_code_1 = ZSTD_CCtx_setCParams(cctx, params.cParams);
3201 if ERR_isError(err_code_1) {
3202 return err_code_1;
3203 }
3204 0
3205}
3206#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_setPledgedSrcSize))]
3207pub unsafe extern "C" fn ZSTD_CCtx_setPledgedSrcSize(
3208 cctx: *mut ZSTD_CCtx,
3209 pledgedSrcSize: core::ffi::c_ulonglong,
3210) -> size_t {
3211 if (*cctx).streamStage as core::ffi::c_uint
3212 != zcss_init as core::ffi::c_int as core::ffi::c_uint
3213 {
3214 return Error::stage_wrong.to_error_code();
3215 }
3216 (*cctx).pledgedSrcSizePlusOne = pledgedSrcSize.wrapping_add(1);
3217 0
3218}
3219unsafe fn ZSTD_initLocalDict(cctx: *mut ZSTD_CCtx) -> size_t {
3220 let dl: *mut ZSTD_localDict = &mut (*cctx).localDict;
3221 if ((*dl).dict).is_null() {
3222 return 0;
3223 }
3224 if !((*dl).cdict).is_null() {
3225 return 0;
3226 }
3227 (*dl).cdict = ZSTD_createCDict_advanced2(
3228 (*dl).dict,
3229 (*dl).dictSize,
3230 ZSTD_dlm_byRef,
3231 (*dl).dictContentType,
3232 &(*cctx).requestedParams,
3233 (*cctx).customMem,
3234 );
3235 if ((*dl).cdict).is_null() {
3236 return Error::memory_allocation.to_error_code();
3237 }
3238 (*cctx).cdict = (*dl).cdict;
3239 0
3240}
3241#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_loadDictionary_advanced))]
3242pub unsafe extern "C" fn ZSTD_CCtx_loadDictionary_advanced(
3243 cctx: *mut ZSTD_CCtx,
3244 dict: *const core::ffi::c_void,
3245 dictSize: size_t,
3246 dictLoadMethod: ZSTD_dictLoadMethod_e,
3247 dictContentType: ZSTD_dictContentType_e,
3248) -> size_t {
3249 if (*cctx).streamStage as core::ffi::c_uint
3250 != zcss_init as core::ffi::c_int as core::ffi::c_uint
3251 {
3252 return Error::stage_wrong.to_error_code();
3253 }
3254 ZSTD_clearAllDicts(cctx);
3255 if dict.is_null() || dictSize == 0 {
3256 return 0;
3257 }
3258 if dictLoadMethod as core::ffi::c_uint
3259 == ZSTD_dlm_byRef as core::ffi::c_int as core::ffi::c_uint
3260 {
3261 (*cctx).localDict.dict = dict;
3262 } else {
3263 let mut dictBuffer = core::ptr::null_mut::<core::ffi::c_void>();
3264 if (*cctx).staticSize != 0 {
3265 return Error::memory_allocation.to_error_code();
3266 }
3267 dictBuffer = ZSTD_customMalloc(dictSize, (*cctx).customMem);
3268 if dictBuffer.is_null() {
3269 return Error::memory_allocation.to_error_code();
3270 }
3271 libc::memcpy(dictBuffer, dict, dictSize as libc::size_t);
3272 (*cctx).localDict.dictBuffer = dictBuffer;
3273 (*cctx).localDict.dict = dictBuffer;
3274 }
3275 (*cctx).localDict.dictSize = dictSize;
3276 (*cctx).localDict.dictContentType = dictContentType;
3277 0
3278}
3279#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_loadDictionary_byReference))]
3280pub unsafe extern "C" fn ZSTD_CCtx_loadDictionary_byReference(
3281 cctx: *mut ZSTD_CCtx,
3282 dict: *const core::ffi::c_void,
3283 dictSize: size_t,
3284) -> size_t {
3285 ZSTD_CCtx_loadDictionary_advanced(cctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto)
3286}
3287#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_loadDictionary))]
3288pub unsafe extern "C" fn ZSTD_CCtx_loadDictionary(
3289 cctx: *mut ZSTD_CCtx,
3290 dict: *const core::ffi::c_void,
3291 dictSize: size_t,
3292) -> size_t {
3293 ZSTD_CCtx_loadDictionary_advanced(cctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto)
3294}
3295#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_refCDict))]
3296pub unsafe extern "C" fn ZSTD_CCtx_refCDict(
3297 cctx: *mut ZSTD_CCtx,
3298 cdict: *const ZSTD_CDict,
3299) -> size_t {
3300 if (*cctx).streamStage as core::ffi::c_uint
3301 != zcss_init as core::ffi::c_int as core::ffi::c_uint
3302 {
3303 return Error::stage_wrong.to_error_code();
3304 }
3305 ZSTD_clearAllDicts(cctx);
3306 (*cctx).cdict = cdict;
3307 0
3308}
3309#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_refThreadPool))]
3310pub unsafe extern "C" fn ZSTD_CCtx_refThreadPool(
3311 cctx: *mut ZSTD_CCtx,
3312 pool: *mut ZSTD_threadPool,
3313) -> size_t {
3314 if (*cctx).streamStage as core::ffi::c_uint
3315 != zcss_init as core::ffi::c_int as core::ffi::c_uint
3316 {
3317 return Error::stage_wrong.to_error_code();
3318 }
3319 (*cctx).pool = pool;
3320 0
3321}
3322#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_refPrefix))]
3323pub unsafe extern "C" fn ZSTD_CCtx_refPrefix(
3324 cctx: *mut ZSTD_CCtx,
3325 prefix: *const core::ffi::c_void,
3326 prefixSize: size_t,
3327) -> size_t {
3328 ZSTD_CCtx_refPrefix_advanced(cctx, prefix, prefixSize, ZSTD_dct_rawContent)
3329}
3330#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_refPrefix_advanced))]
3331pub unsafe extern "C" fn ZSTD_CCtx_refPrefix_advanced(
3332 cctx: *mut ZSTD_CCtx,
3333 prefix: *const core::ffi::c_void,
3334 prefixSize: size_t,
3335 dictContentType: ZSTD_dictContentType_e,
3336) -> size_t {
3337 if (*cctx).streamStage as core::ffi::c_uint
3338 != zcss_init as core::ffi::c_int as core::ffi::c_uint
3339 {
3340 return Error::stage_wrong.to_error_code();
3341 }
3342 ZSTD_clearAllDicts(cctx);
3343 if !prefix.is_null() && prefixSize > 0 {
3344 (*cctx).prefixDict.dict = prefix;
3345 (*cctx).prefixDict.dictSize = prefixSize;
3346 (*cctx).prefixDict.dictContentType = dictContentType;
3347 }
3348 0
3349}
3350#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtx_reset))]
3351pub unsafe extern "C" fn ZSTD_CCtx_reset(
3352 cctx: *mut ZSTD_CCtx,
3353 reset: ZSTD_ResetDirective,
3354) -> size_t {
3355 if reset as core::ffi::c_uint
3356 == ZSTD_reset_session_only as core::ffi::c_int as core::ffi::c_uint
3357 || reset as core::ffi::c_uint
3358 == ZSTD_reset_session_and_parameters as core::ffi::c_int as core::ffi::c_uint
3359 {
3360 (*cctx).streamStage = zcss_init;
3361 (*cctx).pledgedSrcSizePlusOne = 0;
3362 }
3363 if reset as core::ffi::c_uint == ZSTD_reset_parameters as core::ffi::c_int as core::ffi::c_uint
3364 || reset as core::ffi::c_uint
3365 == ZSTD_reset_session_and_parameters as core::ffi::c_int as core::ffi::c_uint
3366 {
3367 if (*cctx).streamStage as core::ffi::c_uint
3368 != zcss_init as core::ffi::c_int as core::ffi::c_uint
3369 {
3370 return Error::stage_wrong.to_error_code();
3371 }
3372 ZSTD_clearAllDicts(cctx);
3373 return ZSTD_CCtxParams_reset(&mut (*cctx).requestedParams);
3374 }
3375 0
3376}
3377#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_checkCParams))]
3378pub unsafe extern "C" fn ZSTD_checkCParams(cParams: ZSTD_compressionParameters) -> size_t {
3379 if ZSTD_cParam_withinBounds(ZSTD_c_windowLog, cParams.windowLog as core::ffi::c_int) == 0 {
3380 return Error::parameter_outOfBound.to_error_code();
3381 }
3382 if ZSTD_cParam_withinBounds(ZSTD_c_chainLog, cParams.chainLog as core::ffi::c_int) == 0 {
3383 return Error::parameter_outOfBound.to_error_code();
3384 }
3385 if ZSTD_cParam_withinBounds(ZSTD_c_hashLog, cParams.hashLog as core::ffi::c_int) == 0 {
3386 return Error::parameter_outOfBound.to_error_code();
3387 }
3388 if ZSTD_cParam_withinBounds(ZSTD_c_searchLog, cParams.searchLog as core::ffi::c_int) == 0 {
3389 return Error::parameter_outOfBound.to_error_code();
3390 }
3391 if ZSTD_cParam_withinBounds(ZSTD_c_minMatch, cParams.minMatch as core::ffi::c_int) == 0 {
3392 return Error::parameter_outOfBound.to_error_code();
3393 }
3394 if ZSTD_cParam_withinBounds(
3395 ZSTD_c_targetLength,
3396 cParams.targetLength as core::ffi::c_int,
3397 ) == 0
3398 {
3399 return Error::parameter_outOfBound.to_error_code();
3400 }
3401 if ZSTD_cParam_withinBounds(ZSTD_c_strategy, cParams.strategy as core::ffi::c_int) == 0 {
3402 return Error::parameter_outOfBound.to_error_code();
3403 }
3404 0
3405}
3406unsafe fn ZSTD_clampCParams(mut cParams: ZSTD_compressionParameters) -> ZSTD_compressionParameters {
3407 let bounds = ZSTD_cParam_getBounds(ZSTD_c_windowLog);
3408 if (cParams.windowLog as core::ffi::c_int) < bounds.lowerBound {
3409 cParams.windowLog = bounds.lowerBound as core::ffi::c_uint;
3410 } else if cParams.windowLog as core::ffi::c_int > bounds.upperBound {
3411 cParams.windowLog = bounds.upperBound as core::ffi::c_uint;
3412 }
3413 let bounds_0 = ZSTD_cParam_getBounds(ZSTD_c_chainLog);
3414 if (cParams.chainLog as core::ffi::c_int) < bounds_0.lowerBound {
3415 cParams.chainLog = bounds_0.lowerBound as core::ffi::c_uint;
3416 } else if cParams.chainLog as core::ffi::c_int > bounds_0.upperBound {
3417 cParams.chainLog = bounds_0.upperBound as core::ffi::c_uint;
3418 }
3419 let bounds_1 = ZSTD_cParam_getBounds(ZSTD_c_hashLog);
3420 if (cParams.hashLog as core::ffi::c_int) < bounds_1.lowerBound {
3421 cParams.hashLog = bounds_1.lowerBound as core::ffi::c_uint;
3422 } else if cParams.hashLog as core::ffi::c_int > bounds_1.upperBound {
3423 cParams.hashLog = bounds_1.upperBound as core::ffi::c_uint;
3424 }
3425 let bounds_2 = ZSTD_cParam_getBounds(ZSTD_c_searchLog);
3426 if (cParams.searchLog as core::ffi::c_int) < bounds_2.lowerBound {
3427 cParams.searchLog = bounds_2.lowerBound as core::ffi::c_uint;
3428 } else if cParams.searchLog as core::ffi::c_int > bounds_2.upperBound {
3429 cParams.searchLog = bounds_2.upperBound as core::ffi::c_uint;
3430 }
3431 let bounds_3 = ZSTD_cParam_getBounds(ZSTD_c_minMatch);
3432 if (cParams.minMatch as core::ffi::c_int) < bounds_3.lowerBound {
3433 cParams.minMatch = bounds_3.lowerBound as core::ffi::c_uint;
3434 } else if cParams.minMatch as core::ffi::c_int > bounds_3.upperBound {
3435 cParams.minMatch = bounds_3.upperBound as core::ffi::c_uint;
3436 }
3437 let bounds_4 = ZSTD_cParam_getBounds(ZSTD_c_targetLength);
3438 if (cParams.targetLength as core::ffi::c_int) < bounds_4.lowerBound {
3439 cParams.targetLength = bounds_4.lowerBound as core::ffi::c_uint;
3440 } else if cParams.targetLength as core::ffi::c_int > bounds_4.upperBound {
3441 cParams.targetLength = bounds_4.upperBound as core::ffi::c_uint;
3442 }
3443 let bounds_5 = ZSTD_cParam_getBounds(ZSTD_c_strategy);
3444 if (cParams.strategy as core::ffi::c_int) < bounds_5.lowerBound {
3445 cParams.strategy = bounds_5.lowerBound as ZSTD_strategy;
3446 } else if cParams.strategy as core::ffi::c_int > bounds_5.upperBound {
3447 cParams.strategy = bounds_5.upperBound as ZSTD_strategy;
3448 }
3449 cParams
3450}
3451#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_cycleLog))]
3452pub unsafe extern "C" fn ZSTD_cycleLog(hashLog: u32, strat: ZSTD_strategy) -> u32 {
3453 let btScale = (strat >= ZSTD_btlazy2) as u32;
3454 hashLog.wrapping_sub(btScale)
3455}
3456unsafe fn ZSTD_dictAndWindowLog(windowLog: u32, srcSize: u64, dictSize: u64) -> u32 {
3457 let maxWindowSize = ((1 as core::ffi::c_ulonglong)
3458 << (if ::core::mem::size_of::<size_t>() == 4 {
3459 ZSTD_WINDOWLOG_MAX_32
3460 } else {
3461 ZSTD_WINDOWLOG_MAX_64
3462 })) as u64;
3463 if dictSize == 0 {
3464 return windowLog;
3465 }
3466 let windowSize = ((1) << windowLog) as u64;
3467 let dictAndWindowSize = dictSize.wrapping_add(windowSize);
3468 if windowSize >= dictSize.wrapping_add(srcSize) {
3469 windowLog
3470 } else if dictAndWindowSize >= maxWindowSize {
3471 (if ::core::mem::size_of::<size_t>() == 4 {
3472 ZSTD_WINDOWLOG_MAX_32
3473 } else {
3474 ZSTD_WINDOWLOG_MAX_64
3475 }) as u32
3476 } else {
3477 (ZSTD_highbit32((dictAndWindowSize as u32).wrapping_sub(1))).wrapping_add(1)
3478 }
3479}
3480unsafe fn ZSTD_adjustCParams_internal(
3481 mut cPar: ZSTD_compressionParameters,
3482 mut srcSize: core::ffi::c_ulonglong,
3483 mut dictSize: size_t,
3484 mode: ZSTD_CParamMode_e,
3485 mut useRowMatchFinder: ZSTD_ParamSwitch_e,
3486) -> ZSTD_compressionParameters {
3487 let minSrcSize = 513;
3488 let maxWindowResize = ((1)
3489 << ((if ::core::mem::size_of::<size_t>() == 4 {
3490 ZSTD_WINDOWLOG_MAX_32
3491 } else {
3492 ZSTD_WINDOWLOG_MAX_64
3493 }) - 1)) as u64;
3494 match mode as core::ffi::c_uint {
3495 2 => {
3496 if dictSize != 0 && srcSize == ZSTD_CONTENTSIZE_UNKNOWN {
3497 srcSize = minSrcSize as core::ffi::c_ulonglong;
3498 }
3499 }
3500 1 => {
3501 dictSize = 0;
3502 }
3503 3 | 0 | _ => {}
3504 }
3505 if srcSize <= maxWindowResize && dictSize as u64 <= maxWindowResize {
3506 let tSize = srcSize.wrapping_add(dictSize as core::ffi::c_ulonglong) as u32;
3507 static hashSizeMin: u32 = ((1) << ZSTD_HASHLOG_MIN) as u32;
3508 let srcLog = if tSize < hashSizeMin {
3509 ZSTD_HASHLOG_MIN as core::ffi::c_uint
3510 } else {
3511 (ZSTD_highbit32(tSize.wrapping_sub(1))).wrapping_add(1)
3512 };
3513 if cPar.windowLog > srcLog {
3514 cPar.windowLog = srcLog;
3515 }
3516 }
3517 if srcSize != ZSTD_CONTENTSIZE_UNKNOWN {
3518 let dictAndWindowLog = ZSTD_dictAndWindowLog(cPar.windowLog, srcSize, dictSize as u64);
3519 let cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
3520 if cPar.hashLog > dictAndWindowLog.wrapping_add(1) {
3521 cPar.hashLog = dictAndWindowLog.wrapping_add(1);
3522 }
3523 if cycleLog > dictAndWindowLog {
3524 cPar.chainLog = (cPar.chainLog).wrapping_sub(cycleLog.wrapping_sub(dictAndWindowLog));
3525 }
3526 }
3527 if cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN as core::ffi::c_uint {
3528 cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN as core::ffi::c_uint;
3529 }
3530 if mode as core::ffi::c_uint == ZSTD_cpm_createCDict as core::ffi::c_int as core::ffi::c_uint
3531 && ZSTD_CDictIndicesAreTagged(&cPar) != 0
3532 {
3533 let maxShortCacheHashLog = (32 - ZSTD_SHORT_CACHE_TAG_BITS) as u32;
3534 if cPar.hashLog > maxShortCacheHashLog {
3535 cPar.hashLog = maxShortCacheHashLog;
3536 }
3537 if cPar.chainLog > maxShortCacheHashLog {
3538 cPar.chainLog = maxShortCacheHashLog;
3539 }
3540 }
3541 if useRowMatchFinder as core::ffi::c_uint
3542 == ZSTD_ps_auto as core::ffi::c_int as core::ffi::c_uint
3543 {
3544 useRowMatchFinder = ZSTD_ps_enable;
3545 }
3546 if ZSTD_rowMatchFinderUsed(cPar.strategy, useRowMatchFinder) != 0 {
3547 let rowLog = if 4
3548 > (if cPar.searchLog < 6 {
3549 cPar.searchLog
3550 } else {
3551 6
3552 }) {
3553 4
3554 } else if cPar.searchLog < 6 {
3555 cPar.searchLog
3556 } else {
3557 6
3558 };
3559 let maxRowHashLog = (32 - ZSTD_ROW_HASH_TAG_BITS) as u32;
3560 let maxHashLog = maxRowHashLog.wrapping_add(rowLog);
3561 if cPar.hashLog > maxHashLog {
3562 cPar.hashLog = maxHashLog;
3563 }
3564 }
3565 cPar
3566}
3567#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_adjustCParams))]
3568pub unsafe extern "C" fn ZSTD_adjustCParams(
3569 mut cPar: ZSTD_compressionParameters,
3570 mut srcSize: core::ffi::c_ulonglong,
3571 dictSize: size_t,
3572) -> ZSTD_compressionParameters {
3573 cPar = ZSTD_clampCParams(cPar);
3574 if srcSize == 0 {
3575 srcSize = ZSTD_CONTENTSIZE_UNKNOWN;
3576 }
3577 ZSTD_adjustCParams_internal(cPar, srcSize, dictSize, ZSTD_cpm_unknown, ZSTD_ps_auto)
3578}
3579unsafe fn ZSTD_overrideCParams(
3580 cParams: *mut ZSTD_compressionParameters,
3581 overrides: *const ZSTD_compressionParameters,
3582) {
3583 if (*overrides).windowLog != 0 {
3584 (*cParams).windowLog = (*overrides).windowLog;
3585 }
3586 if (*overrides).hashLog != 0 {
3587 (*cParams).hashLog = (*overrides).hashLog;
3588 }
3589 if (*overrides).chainLog != 0 {
3590 (*cParams).chainLog = (*overrides).chainLog;
3591 }
3592 if (*overrides).searchLog != 0 {
3593 (*cParams).searchLog = (*overrides).searchLog;
3594 }
3595 if (*overrides).minMatch != 0 {
3596 (*cParams).minMatch = (*overrides).minMatch;
3597 }
3598 if (*overrides).targetLength != 0 {
3599 (*cParams).targetLength = (*overrides).targetLength;
3600 }
3601 if (*overrides).strategy as u64 != 0 {
3602 (*cParams).strategy = (*overrides).strategy;
3603 }
3604}
3605#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_getCParamsFromCCtxParams))]
3606pub unsafe extern "C" fn ZSTD_getCParamsFromCCtxParams(
3607 CCtxParams: *const ZSTD_CCtx_params,
3608 mut srcSizeHint: u64,
3609 dictSize: size_t,
3610 mode: ZSTD_CParamMode_e,
3611) -> ZSTD_compressionParameters {
3612 let mut cParams = ZSTD_compressionParameters {
3613 windowLog: 0,
3614 chainLog: 0,
3615 hashLog: 0,
3616 searchLog: 0,
3617 minMatch: 0,
3618 targetLength: 0,
3619 strategy: 0,
3620 };
3621 if srcSizeHint as core::ffi::c_ulonglong == ZSTD_CONTENTSIZE_UNKNOWN
3622 && (*CCtxParams).srcSizeHint > 0
3623 {
3624 srcSizeHint = (*CCtxParams).srcSizeHint as u64;
3625 }
3626 cParams = ZSTD_getCParams_internal(
3627 (*CCtxParams).compressionLevel,
3628 srcSizeHint as core::ffi::c_ulonglong,
3629 dictSize,
3630 mode,
3631 );
3632 if (*CCtxParams).ldmParams.enableLdm as core::ffi::c_uint
3633 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
3634 {
3635 cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG as core::ffi::c_uint;
3636 }
3637 ZSTD_overrideCParams(&mut cParams, &(*CCtxParams).cParams);
3638 ZSTD_adjustCParams_internal(
3639 cParams,
3640 srcSizeHint as core::ffi::c_ulonglong,
3641 dictSize,
3642 mode,
3643 (*CCtxParams).useRowMatchFinder,
3644 )
3645}
3646unsafe fn ZSTD_sizeof_matchState(
3647 cParams: *const ZSTD_compressionParameters,
3648 useRowMatchFinder: ZSTD_ParamSwitch_e,
3649 enableDedicatedDictSearch: core::ffi::c_int,
3650 forCCtx: u32,
3651) -> size_t {
3652 let chainSize = if ZSTD_allocateChainTable(
3653 (*cParams).strategy,
3654 useRowMatchFinder,
3655 (enableDedicatedDictSearch != 0 && forCCtx == 0) as core::ffi::c_int as u32,
3656 ) != 0
3657 {
3658 (1 as size_t) << (*cParams).chainLog
3659 } else {
3660 0 as size_t
3661 };
3662 let hSize = (1 as size_t) << (*cParams).hashLog;
3663 let hashLog3 = if forCCtx != 0 && (*cParams).minMatch == 3 {
3664 if (17) < (*cParams).windowLog {
3665 17
3666 } else {
3667 (*cParams).windowLog
3668 }
3669 } else {
3670 0
3671 };
3672 let h3Size = if hashLog3 != 0 {
3673 (1 as size_t) << hashLog3
3674 } else {
3675 0 as size_t
3676 };
3677 let tableSpace = chainSize
3678 .wrapping_mul(::core::mem::size_of::<u32>())
3679 .wrapping_add(hSize.wrapping_mul(::core::mem::size_of::<u32>()))
3680 .wrapping_add(h3Size.wrapping_mul(::core::mem::size_of::<u32>()));
3681 let optPotentialSpace = (ZSTD_cwksp_aligned64_alloc_size(
3682 ((MaxML + 1) as size_t).wrapping_mul(::core::mem::size_of::<u32>()),
3683 ))
3684 .wrapping_add(ZSTD_cwksp_aligned64_alloc_size(
3685 ((MaxLL + 1) as size_t).wrapping_mul(::core::mem::size_of::<u32>()),
3686 ))
3687 .wrapping_add(ZSTD_cwksp_aligned64_alloc_size(
3688 ((MaxOff + 1) as size_t).wrapping_mul(::core::mem::size_of::<u32>()),
3689 ))
3690 .wrapping_add(ZSTD_cwksp_aligned64_alloc_size(
3691 (((1) << Litbits) as size_t).wrapping_mul(::core::mem::size_of::<u32>()),
3692 ))
3693 .wrapping_add(ZSTD_cwksp_aligned64_alloc_size(
3694 (ZSTD_OPT_SIZE as size_t).wrapping_mul(::core::mem::size_of::<ZSTD_match_t>()),
3695 ))
3696 .wrapping_add(ZSTD_cwksp_aligned64_alloc_size(
3697 (ZSTD_OPT_SIZE as size_t).wrapping_mul(::core::mem::size_of::<ZSTD_optimal_t>()),
3698 ));
3699 let lazyAdditionalSpace =
3700 if ZSTD_rowMatchFinderUsed((*cParams).strategy, useRowMatchFinder) != 0 {
3701 ZSTD_cwksp_aligned64_alloc_size(hSize)
3702 } else {
3703 0
3704 };
3705 let optSpace = if forCCtx != 0
3706 && (*cParams).strategy as core::ffi::c_uint
3707 >= ZSTD_btopt as core::ffi::c_int as core::ffi::c_uint
3708 {
3709 optPotentialSpace
3710 } else {
3711 0
3712 };
3713 let slackSpace = ZSTD_cwksp_slack_space_required();
3714 tableSpace
3715 .wrapping_add(optSpace)
3716 .wrapping_add(slackSpace)
3717 .wrapping_add(lazyAdditionalSpace)
3718}
3719unsafe fn ZSTD_maxNbSeq(
3720 blockSize: size_t,
3721 minMatch: core::ffi::c_uint,
3722 useSequenceProducer: core::ffi::c_int,
3723) -> size_t {
3724 let divider = (if minMatch == 3 || useSequenceProducer != 0 {
3725 3
3726 } else {
3727 4
3728 }) as u32;
3729 blockSize / divider as size_t
3730}
3731unsafe fn ZSTD_estimateCCtxSize_usingCCtxParams_internal(
3732 cParams: *const ZSTD_compressionParameters,
3733 ldmParams: *const ldmParams_t,
3734 isStatic: core::ffi::c_int,
3735 useRowMatchFinder: ZSTD_ParamSwitch_e,
3736 buffInSize: size_t,
3737 buffOutSize: size_t,
3738 pledgedSrcSize: u64,
3739 useSequenceProducer: core::ffi::c_int,
3740 maxBlockSize: size_t,
3741) -> size_t {
3742 let windowSize = (if 1
3743 > (if (1) << (*cParams).windowLog < pledgedSrcSize as core::ffi::c_ulonglong {
3744 (1) << (*cParams).windowLog
3745 } else {
3746 pledgedSrcSize as core::ffi::c_ulonglong
3747 }) {
3748 1
3749 } else if (1) << (*cParams).windowLog < pledgedSrcSize as core::ffi::c_ulonglong {
3750 (1) << (*cParams).windowLog
3751 } else {
3752 pledgedSrcSize as core::ffi::c_ulonglong
3753 }) as size_t;
3754 let blockSize = if ZSTD_resolveMaxBlockSize(maxBlockSize) < windowSize {
3755 ZSTD_resolveMaxBlockSize(maxBlockSize)
3756 } else {
3757 windowSize
3758 };
3759 let maxNbSeq = ZSTD_maxNbSeq(blockSize, (*cParams).minMatch, useSequenceProducer);
3760 let tokenSpace = (ZSTD_cwksp_alloc_size(WILDCOPY_OVERLENGTH.wrapping_add(blockSize)))
3761 .wrapping_add(ZSTD_cwksp_aligned64_alloc_size(
3762 maxNbSeq.wrapping_mul(::core::mem::size_of::<SeqDef>()),
3763 ))
3764 .wrapping_add(
3765 3 * ZSTD_cwksp_alloc_size(maxNbSeq.wrapping_mul(::core::mem::size_of::<u8>())),
3766 );
3767 let tmpWorkSpace = ZSTD_cwksp_alloc_size(
3768 if ((((8) << 10) + 512) as size_t).wrapping_add(
3769 (::core::mem::size_of::<core::ffi::c_uint>())
3770 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
3771 ) > 8208
3772 {
3773 ((((8) << 10) + 512) as size_t).wrapping_add(
3774 (::core::mem::size_of::<core::ffi::c_uint>())
3775 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
3776 )
3777 } else {
3778 8208
3779 },
3780 );
3781 let blockStateSpace =
3782 2 * ZSTD_cwksp_alloc_size(::core::mem::size_of::<ZSTD_compressedBlockState_t>());
3783 let matchStateSize = ZSTD_sizeof_matchState(cParams, useRowMatchFinder, 0, 1);
3784 let ldmSpace = ZSTD_ldm_getTableSize(*ldmParams);
3785 let maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(*ldmParams, blockSize);
3786 let ldmSeqSpace = if (*ldmParams).enableLdm as core::ffi::c_uint
3787 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
3788 {
3789 ZSTD_cwksp_aligned64_alloc_size(maxNbLdmSeq.wrapping_mul(::core::mem::size_of::<rawSeq>()))
3790 } else {
3791 0
3792 };
3793 let bufferSpace =
3794 (ZSTD_cwksp_alloc_size(buffInSize)).wrapping_add(ZSTD_cwksp_alloc_size(buffOutSize));
3795 let cctxSpace = if isStatic != 0 {
3796 ZSTD_cwksp_alloc_size(::core::mem::size_of::<ZSTD_CCtx>())
3797 } else {
3798 0
3799 };
3800 let maxNbExternalSeq = ZSTD_sequenceBound(blockSize);
3801 let externalSeqSpace = if useSequenceProducer != 0 {
3802 ZSTD_cwksp_aligned64_alloc_size(
3803 maxNbExternalSeq.wrapping_mul(::core::mem::size_of::<ZSTD_Sequence>()),
3804 )
3805 } else {
3806 0
3807 };
3808
3809 cctxSpace
3810 .wrapping_add(tmpWorkSpace)
3811 .wrapping_add(blockStateSpace)
3812 .wrapping_add(ldmSpace)
3813 .wrapping_add(ldmSeqSpace)
3814 .wrapping_add(matchStateSize)
3815 .wrapping_add(tokenSpace)
3816 .wrapping_add(bufferSpace)
3817 .wrapping_add(externalSeqSpace)
3818}
3819#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCCtxSize_usingCCtxParams))]
3820pub unsafe extern "C" fn ZSTD_estimateCCtxSize_usingCCtxParams(
3821 params: *const ZSTD_CCtx_params,
3822) -> size_t {
3823 let cParams =
3824 ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
3825 let useRowMatchFinder = ZSTD_resolveRowMatchFinderMode((*params).useRowMatchFinder, &cParams);
3826 if (*params).nbWorkers > 0 {
3827 return Error::GENERIC.to_error_code();
3828 }
3829 ZSTD_estimateCCtxSize_usingCCtxParams_internal(
3830 &cParams,
3831 &(*params).ldmParams,
3832 1,
3833 useRowMatchFinder,
3834 0,
3835 0,
3836 ZSTD_CONTENTSIZE_UNKNOWN,
3837 ZSTD_hasExtSeqProd(params),
3838 (*params).maxBlockSize,
3839 )
3840}
3841#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCCtxSize_usingCParams))]
3842pub unsafe extern "C" fn ZSTD_estimateCCtxSize_usingCParams(
3843 cParams: ZSTD_compressionParameters,
3844) -> size_t {
3845 let mut initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);
3846 if ZSTD_rowMatchFinderSupported(cParams.strategy) != 0 {
3847 let mut noRowCCtxSize: size_t = 0;
3848 let mut rowCCtxSize: size_t = 0;
3849 initialParams.useRowMatchFinder = ZSTD_ps_disable;
3850 noRowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);
3851 initialParams.useRowMatchFinder = ZSTD_ps_enable;
3852 rowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);
3853 if noRowCCtxSize > rowCCtxSize {
3854 noRowCCtxSize
3855 } else {
3856 rowCCtxSize
3857 }
3858 } else {
3859 ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams)
3860 }
3861}
3862static srcSizeTiers: [core::ffi::c_ulonglong; 4] = [
3863 16 * (1 << 10),
3864 128 * (1 << 10),
3865 256 * (1 << 10),
3866 ZSTD_CONTENTSIZE_UNKNOWN,
3867];
3868unsafe extern "C" fn ZSTD_estimateCCtxSize_internal(compressionLevel: core::ffi::c_int) -> size_t {
3869 let mut tier = 0;
3870 let mut largestSize = 0;
3871 while tier < 4 {
3872 let cParams = ZSTD_getCParams_internal(
3873 compressionLevel,
3874 srcSizeTiers[tier],
3875 0,
3876 ZSTD_cpm_noAttachDict,
3877 );
3878 largestSize = if ZSTD_estimateCCtxSize_usingCParams(cParams) > largestSize {
3879 ZSTD_estimateCCtxSize_usingCParams(cParams)
3880 } else {
3881 largestSize
3882 };
3883 tier += 1;
3884 }
3885 largestSize
3886}
3887#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCCtxSize))]
3888pub unsafe extern "C" fn ZSTD_estimateCCtxSize(compressionLevel: core::ffi::c_int) -> size_t {
3889 let mut level: core::ffi::c_int = 0;
3890 let mut memBudget = 0;
3891 level = if compressionLevel < 1 {
3892 compressionLevel
3893 } else {
3894 1
3895 };
3896 while level <= compressionLevel {
3897 let newMB = ZSTD_estimateCCtxSize_internal(level);
3898 if newMB > memBudget {
3899 memBudget = newMB;
3900 }
3901 level += 1;
3902 }
3903 memBudget
3904}
3905#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCStreamSize_usingCCtxParams))]
3906pub unsafe extern "C" fn ZSTD_estimateCStreamSize_usingCCtxParams(
3907 params: *const ZSTD_CCtx_params,
3908) -> size_t {
3909 if (*params).nbWorkers > 0 {
3910 return Error::GENERIC.to_error_code();
3911 }
3912 let cParams =
3913 ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
3914 let blockSize = if ZSTD_resolveMaxBlockSize((*params).maxBlockSize) < (1) << cParams.windowLog {
3915 ZSTD_resolveMaxBlockSize((*params).maxBlockSize)
3916 } else {
3917 (1) << cParams.windowLog
3918 };
3919 let inBuffSize = if (*params).inBufferMode as core::ffi::c_uint
3920 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint
3921 {
3922 ((1 as size_t) << cParams.windowLog).wrapping_add(blockSize)
3923 } else {
3924 0
3925 };
3926 let outBuffSize = if (*params).outBufferMode as core::ffi::c_uint
3927 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint
3928 {
3929 (ZSTD_compressBound(blockSize)).wrapping_add(1)
3930 } else {
3931 0
3932 };
3933 let useRowMatchFinder =
3934 ZSTD_resolveRowMatchFinderMode((*params).useRowMatchFinder, &(*params).cParams);
3935 ZSTD_estimateCCtxSize_usingCCtxParams_internal(
3936 &cParams,
3937 &(*params).ldmParams,
3938 1,
3939 useRowMatchFinder,
3940 inBuffSize,
3941 outBuffSize,
3942 ZSTD_CONTENTSIZE_UNKNOWN,
3943 ZSTD_hasExtSeqProd(params),
3944 (*params).maxBlockSize,
3945 )
3946}
3947#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCStreamSize_usingCParams))]
3948pub unsafe extern "C" fn ZSTD_estimateCStreamSize_usingCParams(
3949 cParams: ZSTD_compressionParameters,
3950) -> size_t {
3951 let mut initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);
3952 if ZSTD_rowMatchFinderSupported(cParams.strategy) != 0 {
3953 let mut noRowCCtxSize: size_t = 0;
3954 let mut rowCCtxSize: size_t = 0;
3955 initialParams.useRowMatchFinder = ZSTD_ps_disable;
3956 noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
3957 initialParams.useRowMatchFinder = ZSTD_ps_enable;
3958 rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
3959 if noRowCCtxSize > rowCCtxSize {
3960 noRowCCtxSize
3961 } else {
3962 rowCCtxSize
3963 }
3964 } else {
3965 ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams)
3966 }
3967}
3968unsafe fn ZSTD_estimateCStreamSize_internal(compressionLevel: core::ffi::c_int) -> size_t {
3969 let cParams = ZSTD_getCParams_internal(
3970 compressionLevel,
3971 ZSTD_CONTENTSIZE_UNKNOWN,
3972 0,
3973 ZSTD_cpm_noAttachDict,
3974 );
3975 ZSTD_estimateCStreamSize_usingCParams(cParams)
3976}
3977#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCStreamSize))]
3978pub unsafe extern "C" fn ZSTD_estimateCStreamSize(compressionLevel: core::ffi::c_int) -> size_t {
3979 let mut level: core::ffi::c_int = 0;
3980 let mut memBudget = 0;
3981 level = if compressionLevel < 1 {
3982 compressionLevel
3983 } else {
3984 1
3985 };
3986 while level <= compressionLevel {
3987 let newMB = ZSTD_estimateCStreamSize_internal(level);
3988 if newMB > memBudget {
3989 memBudget = newMB;
3990 }
3991 level += 1;
3992 }
3993 memBudget
3994}
3995#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_getFrameProgression))]
3996pub unsafe extern "C" fn ZSTD_getFrameProgression(cctx: *const ZSTD_CCtx) -> ZSTD_frameProgression {
3997 if (*cctx).appliedParams.nbWorkers > 0 {
3998 return ZSTDMT_getFrameProgression((*cctx).mtctx);
3999 }
4000 let mut fp = ZSTD_frameProgression {
4001 ingested: 0,
4002 consumed: 0,
4003 produced: 0,
4004 flushed: 0,
4005 currentJobID: 0,
4006 nbActiveWorkers: 0,
4007 };
4008 let buffered = if ((*cctx).inBuff).is_null() {
4009 0
4010 } else {
4011 ((*cctx).inBuffPos).wrapping_sub((*cctx).inToCompress)
4012 };
4013 buffered != 0;
4014 fp.ingested = ((*cctx).consumedSrcSize).wrapping_add(buffered as core::ffi::c_ulonglong);
4015 fp.consumed = (*cctx).consumedSrcSize;
4016 fp.produced = (*cctx).producedCSize;
4017 fp.flushed = (*cctx).producedCSize;
4018 fp.currentJobID = 0;
4019 fp.nbActiveWorkers = 0;
4020 fp
4021}
4022#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_toFlushNow))]
4023pub unsafe extern "C" fn ZSTD_toFlushNow(cctx: *mut ZSTD_CCtx) -> size_t {
4024 if (*cctx).appliedParams.nbWorkers > 0 {
4025 return ZSTDMT_toFlushNow((*cctx).mtctx);
4026 }
4027 0
4028}
4029unsafe fn ZSTD_assertEqualCParams(
4030 cParams1: ZSTD_compressionParameters,
4031 cParams2: ZSTD_compressionParameters,
4032) {
4033}
4034pub unsafe fn ZSTD_reset_compressedBlockState(bs: *mut ZSTD_compressedBlockState_t) {
4035 let mut i: core::ffi::c_int = 0;
4036 i = 0;
4037 while i < ZSTD_REP_NUM {
4038 *((*bs).rep).as_mut_ptr().offset(i as isize) = *repStartValue.as_ptr().offset(i as isize);
4039 i += 1;
4040 }
4041 (*bs).entropy.huf.repeatMode = HUF_repeat_none;
4042 (*bs).entropy.fse.offcode_repeatMode = FSE_repeat_none;
4043 (*bs).entropy.fse.matchlength_repeatMode = FSE_repeat_none;
4044 (*bs).entropy.fse.litlength_repeatMode = FSE_repeat_none;
4045}
4046unsafe fn ZSTD_invalidateMatchState(ms: *mut ZSTD_MatchState_t) {
4047 ZSTD_window_clear(&mut (*ms).window);
4048 (*ms).nextToUpdate = (*ms).window.dictLimit;
4049 (*ms).loadedDictEnd = 0;
4050 (*ms).opt.litLengthSum = 0;
4051 (*ms).dictMatchState = core::ptr::null();
4052}
4053unsafe fn ZSTD_bitmix(mut val: u64, len: u64) -> u64 {
4054 val ^= ZSTD_rotateRight_U64(val, 49) ^ ZSTD_rotateRight_U64(val, 24);
4055 val = val.wrapping_mul(0x9fb21c651e98df25u64);
4056 val ^= (val >> 35).wrapping_add(len);
4057 val = val.wrapping_mul(0x9fb21c651e98df25u64);
4058 val ^ val >> 28
4059}
4060unsafe fn ZSTD_advanceHashSalt(ms: *mut ZSTD_MatchState_t) {
4061 (*ms).hashSalt = ZSTD_bitmix((*ms).hashSalt, 8) ^ ZSTD_bitmix((*ms).hashSaltEntropy as u64, 4);
4062}
4063unsafe fn ZSTD_reset_matchState(
4064 ms: *mut ZSTD_MatchState_t,
4065 ws: *mut ZSTD_cwksp,
4066 cParams: *const ZSTD_compressionParameters,
4067 useRowMatchFinder: ZSTD_ParamSwitch_e,
4068 crp: ZSTD_compResetPolicy_e,
4069 forceResetIndex: ZSTD_indexResetPolicy_e,
4070 forWho: ZSTD_resetTarget_e,
4071) -> size_t {
4072 let chainSize = if ZSTD_allocateChainTable(
4073 (*cParams).strategy,
4074 useRowMatchFinder,
4075 ((*ms).dedicatedDictSearch != 0
4076 && forWho as core::ffi::c_uint
4077 == ZSTD_resetTarget_CDict as core::ffi::c_int as core::ffi::c_uint)
4078 as core::ffi::c_int as u32,
4079 ) != 0
4080 {
4081 (1 as size_t) << (*cParams).chainLog
4082 } else {
4083 0 as size_t
4084 };
4085 let hSize = (1 as size_t) << (*cParams).hashLog;
4086 let hashLog3 = if forWho as core::ffi::c_uint
4087 == ZSTD_resetTarget_CCtx as core::ffi::c_int as core::ffi::c_uint
4088 && (*cParams).minMatch == 3
4089 {
4090 if (17) < (*cParams).windowLog {
4091 17
4092 } else {
4093 (*cParams).windowLog
4094 }
4095 } else {
4096 0
4097 };
4098 let h3Size = if hashLog3 != 0 {
4099 (1 as size_t) << hashLog3
4100 } else {
4101 0 as size_t
4102 };
4103 if forceResetIndex as core::ffi::c_uint
4104 == ZSTDirp_reset as core::ffi::c_int as core::ffi::c_uint
4105 {
4106 ZSTD_window_init(&mut (*ms).window);
4107 ZSTD_cwksp_mark_tables_dirty(ws);
4108 }
4109 (*ms).hashLog3 = hashLog3;
4110 (*ms).lazySkipping = 0;
4111 ZSTD_invalidateMatchState(ms);
4112 ZSTD_cwksp_clear_tables(ws);
4113 (*ms).hashTable =
4114 ZSTD_cwksp_reserve_table(ws, hSize.wrapping_mul(::core::mem::size_of::<u32>())) as *mut u32;
4115 (*ms).chainTable =
4116 ZSTD_cwksp_reserve_table(ws, chainSize.wrapping_mul(::core::mem::size_of::<u32>()))
4117 as *mut u32;
4118 (*ms).hashTable3 =
4119 ZSTD_cwksp_reserve_table(ws, h3Size.wrapping_mul(::core::mem::size_of::<u32>()))
4120 as *mut u32;
4121 if ZSTD_cwksp_reserve_failed(ws) != 0 {
4122 return Error::memory_allocation.to_error_code();
4123 }
4124 if crp as core::ffi::c_uint != ZSTDcrp_leaveDirty as core::ffi::c_int as core::ffi::c_uint {
4125 ZSTD_cwksp_clean_tables(ws);
4126 }
4127 if ZSTD_rowMatchFinderUsed((*cParams).strategy, useRowMatchFinder) != 0 {
4128 let tagTableSize = hSize;
4129 if forWho as core::ffi::c_uint
4130 == ZSTD_resetTarget_CCtx as core::ffi::c_int as core::ffi::c_uint
4131 {
4132 (*ms).tagTable = ZSTD_cwksp_reserve_aligned_init_once(ws, tagTableSize) as *mut u8;
4133 ZSTD_advanceHashSalt(ms);
4134 } else {
4135 (*ms).tagTable = ZSTD_cwksp_reserve_aligned64(ws, tagTableSize) as *mut u8;
4136 ptr::write_bytes((*ms).tagTable as *mut u8, 0, tagTableSize);
4137 (*ms).hashSalt = 0;
4138 }
4139 let rowLog = if 4
4140 > (if (*cParams).searchLog < 6 {
4141 (*cParams).searchLog
4142 } else {
4143 6
4144 }) {
4145 4
4146 } else if (*cParams).searchLog < 6 {
4147 (*cParams).searchLog
4148 } else {
4149 6
4150 };
4151 (*ms).rowHashLog = ((*cParams).hashLog).wrapping_sub(rowLog);
4152 }
4153 if forWho as core::ffi::c_uint == ZSTD_resetTarget_CCtx as core::ffi::c_int as core::ffi::c_uint
4154 && (*cParams).strategy as core::ffi::c_uint
4155 >= ZSTD_btopt as core::ffi::c_int as core::ffi::c_uint
4156 {
4157 (*ms).opt.litFreq = ZSTD_cwksp_reserve_aligned64(
4158 ws,
4159 (((1) << Litbits) as size_t).wrapping_mul(::core::mem::size_of::<core::ffi::c_uint>()),
4160 ) as *mut core::ffi::c_uint;
4161 (*ms).opt.litLengthFreq = ZSTD_cwksp_reserve_aligned64(
4162 ws,
4163 ((MaxLL + 1) as size_t).wrapping_mul(::core::mem::size_of::<core::ffi::c_uint>()),
4164 ) as *mut core::ffi::c_uint;
4165 (*ms).opt.matchLengthFreq = ZSTD_cwksp_reserve_aligned64(
4166 ws,
4167 ((MaxML + 1) as size_t).wrapping_mul(::core::mem::size_of::<core::ffi::c_uint>()),
4168 ) as *mut core::ffi::c_uint;
4169 (*ms).opt.offCodeFreq = ZSTD_cwksp_reserve_aligned64(
4170 ws,
4171 ((MaxOff + 1) as size_t).wrapping_mul(::core::mem::size_of::<core::ffi::c_uint>()),
4172 ) as *mut core::ffi::c_uint;
4173 (*ms).opt.matchTable = ZSTD_cwksp_reserve_aligned64(
4174 ws,
4175 (ZSTD_OPT_SIZE as size_t).wrapping_mul(::core::mem::size_of::<ZSTD_match_t>()),
4176 ) as *mut ZSTD_match_t;
4177 (*ms).opt.priceTable = ZSTD_cwksp_reserve_aligned64(
4178 ws,
4179 (ZSTD_OPT_SIZE as size_t).wrapping_mul(::core::mem::size_of::<ZSTD_optimal_t>()),
4180 ) as *mut ZSTD_optimal_t;
4181 }
4182 (*ms).cParams = *cParams;
4183 if ZSTD_cwksp_reserve_failed(ws) != 0 {
4184 return Error::memory_allocation.to_error_code();
4185 }
4186 0
4187}
4188pub const ZSTD_INDEXOVERFLOW_MARGIN: core::ffi::c_int = 16 * ((1) << 20);
4189unsafe fn ZSTD_indexTooCloseToMax(w: ZSTD_window_t) -> core::ffi::c_int {
4190 ((w.nextSrc).offset_from(w.base) as size_t
4191 > (if MEM_64bits() != 0 {
4192 (3500 as core::ffi::c_uint)
4193 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
4194 } else {
4195 (2000 as core::ffi::c_uint)
4196 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
4197 })
4198 .wrapping_sub(ZSTD_INDEXOVERFLOW_MARGIN as core::ffi::c_uint) as size_t)
4199 as core::ffi::c_int
4200}
4201unsafe fn ZSTD_dictTooBig(loadedDictSize: size_t) -> core::ffi::c_int {
4202 (loadedDictSize
4203 > (-(1 as core::ffi::c_int) as u32).wrapping_sub(if MEM_64bits() != 0 {
4204 (3500 as core::ffi::c_uint)
4205 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
4206 } else {
4207 (2000 as core::ffi::c_uint)
4208 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
4209 }) as size_t) as core::ffi::c_int
4210}
4211unsafe fn ZSTD_resetCCtx_internal(
4212 zc: *mut ZSTD_CCtx,
4213 mut params: *const ZSTD_CCtx_params,
4214 pledgedSrcSize: u64,
4215 loadedDictSize: size_t,
4216 crp: ZSTD_compResetPolicy_e,
4217 zbuff: ZSTD_buffered_policy_e,
4218) -> size_t {
4219 let ws: *mut ZSTD_cwksp = &mut (*zc).workspace;
4220 (*zc).isFirstBlock = 1;
4221 (*zc).appliedParams = *params;
4222 params = &mut (*zc).appliedParams;
4223 if (*params).ldmParams.enableLdm as core::ffi::c_uint
4224 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
4225 {
4226 ZSTD_ldm_adjustParameters(&mut (*zc).appliedParams.ldmParams, &(*params).cParams);
4227 }
4228 let windowSize = if 1
4229 > (if (1 as size_t) << (*params).cParams.windowLog < pledgedSrcSize as size_t {
4230 (1 as size_t) << (*params).cParams.windowLog
4231 } else {
4232 pledgedSrcSize as size_t
4233 }) {
4234 1
4235 } else if (1 as size_t) << (*params).cParams.windowLog < pledgedSrcSize as size_t {
4236 (1 as size_t) << (*params).cParams.windowLog
4237 } else {
4238 pledgedSrcSize as size_t
4239 };
4240 let blockSize = if (*params).maxBlockSize < windowSize {
4241 (*params).maxBlockSize
4242 } else {
4243 windowSize
4244 };
4245 let maxNbSeq = ZSTD_maxNbSeq(
4246 blockSize,
4247 (*params).cParams.minMatch,
4248 ZSTD_hasExtSeqProd(params),
4249 );
4250 let buffOutSize = if zbuff as core::ffi::c_uint
4251 == ZSTDb_buffered as core::ffi::c_int as core::ffi::c_uint
4252 && (*params).outBufferMode as core::ffi::c_uint
4253 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint
4254 {
4255 (ZSTD_compressBound(blockSize)).wrapping_add(1)
4256 } else {
4257 0
4258 };
4259 let buffInSize = if zbuff as core::ffi::c_uint
4260 == ZSTDb_buffered as core::ffi::c_int as core::ffi::c_uint
4261 && (*params).inBufferMode as core::ffi::c_uint
4262 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint
4263 {
4264 windowSize.wrapping_add(blockSize)
4265 } else {
4266 0
4267 };
4268 let maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq((*params).ldmParams, blockSize);
4269 let indexTooClose = ZSTD_indexTooCloseToMax((*zc).blockState.matchState.window);
4270 let dictTooBig = ZSTD_dictTooBig(loadedDictSize);
4271 let mut needsIndexReset = (if indexTooClose != 0 || dictTooBig != 0 || (*zc).initialized == 0 {
4272 ZSTDirp_reset as core::ffi::c_int
4273 } else {
4274 ZSTDirp_continue as core::ffi::c_int
4275 }) as ZSTD_indexResetPolicy_e;
4276 let neededSpace = ZSTD_estimateCCtxSize_usingCCtxParams_internal(
4277 &(*params).cParams,
4278 &(*params).ldmParams,
4279 ((*zc).staticSize != 0) as core::ffi::c_int,
4280 (*params).useRowMatchFinder,
4281 buffInSize,
4282 buffOutSize,
4283 pledgedSrcSize,
4284 ZSTD_hasExtSeqProd(params),
4285 (*params).maxBlockSize,
4286 );
4287 let err_code = neededSpace;
4288 if ERR_isError(err_code) {
4289 return err_code;
4290 }
4291 if (*zc).staticSize == 0 {
4292 ZSTD_cwksp_bump_oversized_duration(ws, 0);
4293 }
4294 let workspaceTooSmall = (ZSTD_cwksp_sizeof(ws) < neededSpace) as core::ffi::c_int;
4295 let workspaceWasteful = ZSTD_cwksp_check_wasteful(ws, neededSpace);
4296 let resizeWorkspace = (workspaceTooSmall != 0 || workspaceWasteful != 0) as core::ffi::c_int;
4297 if resizeWorkspace != 0 {
4298 if (*zc).staticSize != 0 {
4299 return Error::memory_allocation.to_error_code();
4300 }
4301 needsIndexReset = ZSTDirp_reset;
4302 ZSTD_cwksp_free(ws, (*zc).customMem);
4303 let err_code_0 = ZSTD_cwksp_create(ws, neededSpace, (*zc).customMem);
4304 if ERR_isError(err_code_0) {
4305 return err_code_0;
4306 }
4307 (*zc).blockState.prevCBlock =
4308 ZSTD_cwksp_reserve_object(ws, ::core::mem::size_of::<ZSTD_compressedBlockState_t>())
4309 as *mut ZSTD_compressedBlockState_t;
4310 if ((*zc).blockState.prevCBlock).is_null() {
4311 return Error::memory_allocation.to_error_code();
4312 }
4313 (*zc).blockState.nextCBlock =
4314 ZSTD_cwksp_reserve_object(ws, ::core::mem::size_of::<ZSTD_compressedBlockState_t>())
4315 as *mut ZSTD_compressedBlockState_t;
4316 if ((*zc).blockState.nextCBlock).is_null() {
4317 return Error::memory_allocation.to_error_code();
4318 }
4319 (*zc).tmpWorkspace = ZSTD_cwksp_reserve_object(
4320 ws,
4321 if ((((8) << 10) + 512) as size_t).wrapping_add(
4322 (::core::mem::size_of::<core::ffi::c_uint>())
4323 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
4324 ) > 8208
4325 {
4326 ((((8) << 10) + 512) as size_t).wrapping_add(
4327 (::core::mem::size_of::<core::ffi::c_uint>())
4328 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
4329 )
4330 } else {
4331 8208
4332 },
4333 );
4334 if ((*zc).tmpWorkspace).is_null() {
4335 return Error::memory_allocation.to_error_code();
4336 }
4337 (*zc).tmpWkspSize = if ((((8) << 10) + 512) as size_t).wrapping_add(
4338 (::core::mem::size_of::<core::ffi::c_uint>())
4339 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
4340 ) > 8208
4341 {
4342 ((((8) << 10) + 512) as size_t).wrapping_add(
4343 (::core::mem::size_of::<core::ffi::c_uint>())
4344 .wrapping_mul(((if 35 > 52 { 35 } else { 52 }) + 2) as size_t),
4345 )
4346 } else {
4347 8208
4348 };
4349 }
4350 ZSTD_cwksp_clear(ws);
4351 (*zc).blockState.matchState.cParams = (*params).cParams;
4352 (*zc).blockState.matchState.prefetchCDictTables =
4353 ((*params).prefetchCDictTables as core::ffi::c_uint
4354 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint) as core::ffi::c_int;
4355 (*zc).pledgedSrcSizePlusOne = pledgedSrcSize.wrapping_add(1) as core::ffi::c_ulonglong;
4356 (*zc).consumedSrcSize = 0;
4357 (*zc).producedCSize = 0;
4358 if pledgedSrcSize as core::ffi::c_ulonglong == ZSTD_CONTENTSIZE_UNKNOWN {
4359 (*zc).appliedParams.fParams.contentSizeFlag = 0;
4360 }
4361 (*zc).blockSizeMax = blockSize;
4362 ZSTD_XXH64_reset(&mut (*zc).xxhState, 0);
4363 (*zc).stage = ZSTDcs_init;
4364 (*zc).dictID = 0;
4365 (*zc).dictContentSize = 0;
4366 ZSTD_reset_compressedBlockState((*zc).blockState.prevCBlock);
4367 let err_code_1 = ZSTD_reset_matchState(
4368 &mut (*zc).blockState.matchState,
4369 ws,
4370 &(*params).cParams,
4371 (*params).useRowMatchFinder,
4372 crp,
4373 needsIndexReset,
4374 ZSTD_resetTarget_CCtx,
4375 );
4376 if ERR_isError(err_code_1) {
4377 return err_code_1;
4378 }
4379 (*zc).seqStore.sequencesStart =
4380 ZSTD_cwksp_reserve_aligned64(ws, maxNbSeq.wrapping_mul(::core::mem::size_of::<SeqDef>()))
4381 as *mut SeqDef;
4382 if (*params).ldmParams.enableLdm as core::ffi::c_uint
4383 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
4384 {
4385 let ldmHSize = (1 as size_t) << (*params).ldmParams.hashLog;
4386 (*zc).ldmState.hashTable = ZSTD_cwksp_reserve_aligned64(
4387 ws,
4388 ldmHSize.wrapping_mul(::core::mem::size_of::<ldmEntry_t>()),
4389 ) as *mut ldmEntry_t;
4390 ptr::write_bytes(
4391 (*zc).ldmState.hashTable as *mut u8,
4392 0,
4393 ldmHSize.wrapping_mul(::core::mem::size_of::<ldmEntry_t>()),
4394 );
4395 (*zc).ldmSequences = ZSTD_cwksp_reserve_aligned64(
4396 ws,
4397 maxNbLdmSeq.wrapping_mul(::core::mem::size_of::<rawSeq>()),
4398 ) as *mut rawSeq;
4399 (*zc).maxNbLdmSequences = maxNbLdmSeq;
4400 ZSTD_window_init(&mut (*zc).ldmState.window);
4401 (*zc).ldmState.loadedDictEnd = 0;
4402 }
4403 if ZSTD_hasExtSeqProd(params) != 0 {
4404 let maxNbExternalSeq = ZSTD_sequenceBound(blockSize);
4405 (*zc).extSeqBufCapacity = maxNbExternalSeq;
4406 (*zc).extSeqBuf = ZSTD_cwksp_reserve_aligned64(
4407 ws,
4408 maxNbExternalSeq.wrapping_mul(::core::mem::size_of::<ZSTD_Sequence>()),
4409 ) as *mut ZSTD_Sequence;
4410 }
4411 (*zc).seqStore.litStart =
4412 ZSTD_cwksp_reserve_buffer(ws, blockSize.wrapping_add(WILDCOPY_OVERLENGTH));
4413 (*zc).seqStore.maxNbLit = blockSize;
4414 (*zc).bufferedPolicy = zbuff;
4415 (*zc).inBuffSize = buffInSize;
4416 (*zc).inBuff = ZSTD_cwksp_reserve_buffer(ws, buffInSize) as *mut core::ffi::c_char;
4417 (*zc).outBuffSize = buffOutSize;
4418 (*zc).outBuff = ZSTD_cwksp_reserve_buffer(ws, buffOutSize) as *mut core::ffi::c_char;
4419 if (*params).ldmParams.enableLdm as core::ffi::c_uint
4420 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
4421 {
4422 let numBuckets =
4423 (1) << ((*params).ldmParams.hashLog).wrapping_sub((*params).ldmParams.bucketSizeLog);
4424 (*zc).ldmState.bucketOffsets = ZSTD_cwksp_reserve_buffer(ws, numBuckets);
4425 ptr::write_bytes((*zc).ldmState.bucketOffsets as *mut u8, 0, numBuckets);
4426 }
4427 ZSTD_referenceExternalSequences(zc, core::ptr::null_mut(), 0);
4428 (*zc).seqStore.maxNbSeq = maxNbSeq;
4429 (*zc).seqStore.llCode =
4430 ZSTD_cwksp_reserve_buffer(ws, maxNbSeq.wrapping_mul(::core::mem::size_of::<u8>()));
4431 (*zc).seqStore.mlCode =
4432 ZSTD_cwksp_reserve_buffer(ws, maxNbSeq.wrapping_mul(::core::mem::size_of::<u8>()));
4433 (*zc).seqStore.ofCode =
4434 ZSTD_cwksp_reserve_buffer(ws, maxNbSeq.wrapping_mul(::core::mem::size_of::<u8>()));
4435 (*zc).initialized = 1;
4436 0
4437}
4438pub unsafe fn ZSTD_invalidateRepCodes(cctx: *mut ZSTD_CCtx) {
4439 let mut i: core::ffi::c_int = 0;
4440 i = 0;
4441 while i < ZSTD_REP_NUM {
4442 *((*(*cctx).blockState.prevCBlock).rep)
4443 .as_mut_ptr()
4444 .offset(i as isize) = 0;
4445 i += 1;
4446 }
4447}
4448static attachDictSizeCutoffs: [size_t; 10] = [
4449 (8 * ((1) << 10)) as size_t,
4450 (8 * ((1) << 10)) as size_t,
4451 (16 * ((1) << 10)) as size_t,
4452 (32 * ((1) << 10)) as size_t,
4453 (32 * ((1) << 10)) as size_t,
4454 (32 * ((1) << 10)) as size_t,
4455 (32 * ((1) << 10)) as size_t,
4456 (32 * ((1) << 10)) as size_t,
4457 (8 * ((1) << 10)) as size_t,
4458 (8 * ((1) << 10)) as size_t,
4459];
4460unsafe fn ZSTD_shouldAttachDict(
4461 cdict: *const ZSTD_CDict,
4462 params: *const ZSTD_CCtx_params,
4463 pledgedSrcSize: u64,
4464) -> core::ffi::c_int {
4465 let cutoff = *attachDictSizeCutoffs
4466 .as_ptr()
4467 .offset((*cdict).matchState.cParams.strategy as isize);
4468 let dedicatedDictSearch = (*cdict).matchState.dedicatedDictSearch;
4469 (dedicatedDictSearch != 0
4470 || (pledgedSrcSize <= cutoff as u64
4471 || pledgedSrcSize as core::ffi::c_ulonglong == ZSTD_CONTENTSIZE_UNKNOWN
4472 || (*params).attachDictPref as core::ffi::c_uint
4473 == ZSTD_dictForceAttach as core::ffi::c_int as core::ffi::c_uint)
4474 && (*params).attachDictPref as core::ffi::c_uint
4475 != ZSTD_dictForceCopy as core::ffi::c_int as core::ffi::c_uint
4476 && (*params).forceWindow == 0) as core::ffi::c_int
4477}
4478unsafe fn ZSTD_resetCCtx_byAttachingCDict(
4479 cctx: *mut ZSTD_CCtx,
4480 cdict: *const ZSTD_CDict,
4481 mut params: ZSTD_CCtx_params,
4482 pledgedSrcSize: u64,
4483 zbuff: ZSTD_buffered_policy_e,
4484) -> size_t {
4485 let mut adjusted_cdict_cParams = (*cdict).matchState.cParams;
4486 let windowLog = params.cParams.windowLog;
4487 if (*cdict).matchState.dedicatedDictSearch != 0 {
4488 ZSTD_dedicatedDictSearch_revertCParams(&mut adjusted_cdict_cParams);
4489 }
4490 params.cParams = ZSTD_adjustCParams_internal(
4491 adjusted_cdict_cParams,
4492 pledgedSrcSize as core::ffi::c_ulonglong,
4493 (*cdict).dictContentSize,
4494 ZSTD_cpm_attachDict,
4495 params.useRowMatchFinder,
4496 );
4497 params.cParams.windowLog = windowLog;
4498 params.useRowMatchFinder = (*cdict).useRowMatchFinder;
4499 let err_code =
4500 ZSTD_resetCCtx_internal(cctx, ¶ms, pledgedSrcSize, 0, ZSTDcrp_makeClean, zbuff);
4501 if ERR_isError(err_code) {
4502 return err_code;
4503 }
4504 let cdictEnd = ((*cdict).matchState.window.nextSrc).offset_from((*cdict).matchState.window.base)
4505 as core::ffi::c_long as u32;
4506 let cdictLen = cdictEnd.wrapping_sub((*cdict).matchState.window.dictLimit);
4507 if cdictLen != 0 {
4508 (*cctx).blockState.matchState.dictMatchState = &(*cdict).matchState;
4509 if (*cctx).blockState.matchState.window.dictLimit < cdictEnd {
4510 (*cctx).blockState.matchState.window.nextSrc =
4511 ((*cctx).blockState.matchState.window.base).offset(cdictEnd as isize);
4512 ZSTD_window_clear(&mut (*cctx).blockState.matchState.window);
4513 }
4514 (*cctx).blockState.matchState.loadedDictEnd =
4515 (*cctx).blockState.matchState.window.dictLimit;
4516 }
4517 (*cctx).dictID = (*cdict).dictID;
4518 (*cctx).dictContentSize = (*cdict).dictContentSize;
4519 libc::memcpy(
4520 (*cctx).blockState.prevCBlock as *mut core::ffi::c_void,
4521 &(*cdict).cBlockState as *const ZSTD_compressedBlockState_t as *const core::ffi::c_void,
4522 ::core::mem::size_of::<ZSTD_compressedBlockState_t>(),
4523 );
4524 0
4525}
4526unsafe fn ZSTD_copyCDictTableIntoCCtx(
4527 dst: *mut u32,
4528 src: *const u32,
4529 tableSize: size_t,
4530 cParams: *const ZSTD_compressionParameters,
4531) {
4532 if ZSTD_CDictIndicesAreTagged(cParams) != 0 {
4533 let mut i: size_t = 0;
4534 i = 0;
4535 while i < tableSize {
4536 let taggedIndex = *src.add(i);
4537 let index = taggedIndex >> ZSTD_SHORT_CACHE_TAG_BITS;
4538 *dst.add(i) = index;
4539 i = i.wrapping_add(1);
4540 }
4541 } else {
4542 libc::memcpy(
4543 dst as *mut core::ffi::c_void,
4544 src as *const core::ffi::c_void,
4545 tableSize.wrapping_mul(::core::mem::size_of::<u32>()),
4546 );
4547 };
4548}
4549unsafe fn ZSTD_resetCCtx_byCopyingCDict(
4550 cctx: *mut ZSTD_CCtx,
4551 cdict: *const ZSTD_CDict,
4552 mut params: ZSTD_CCtx_params,
4553 pledgedSrcSize: u64,
4554 zbuff: ZSTD_buffered_policy_e,
4555) -> size_t {
4556 let cdict_cParams: *const ZSTD_compressionParameters = &(*cdict).matchState.cParams;
4557 let windowLog = params.cParams.windowLog;
4558 params.cParams = *cdict_cParams;
4559 params.cParams.windowLog = windowLog;
4560 params.useRowMatchFinder = (*cdict).useRowMatchFinder;
4561 let err_code =
4562 ZSTD_resetCCtx_internal(cctx, ¶ms, pledgedSrcSize, 0, ZSTDcrp_leaveDirty, zbuff);
4563 if ERR_isError(err_code) {
4564 return err_code;
4565 }
4566 ZSTD_cwksp_mark_tables_dirty(&mut (*cctx).workspace);
4567 let chainSize =
4568 if ZSTD_allocateChainTable((*cdict_cParams).strategy, (*cdict).useRowMatchFinder, 0) != 0 {
4569 (1) << (*cdict_cParams).chainLog
4570 } else {
4571 0
4572 };
4573 let hSize = (1) << (*cdict_cParams).hashLog;
4574 ZSTD_copyCDictTableIntoCCtx(
4575 (*cctx).blockState.matchState.hashTable,
4576 (*cdict).matchState.hashTable,
4577 hSize,
4578 cdict_cParams,
4579 );
4580 if ZSTD_allocateChainTable(
4581 (*cctx).appliedParams.cParams.strategy,
4582 (*cctx).appliedParams.useRowMatchFinder,
4583 0,
4584 ) != 0
4585 {
4586 ZSTD_copyCDictTableIntoCCtx(
4587 (*cctx).blockState.matchState.chainTable,
4588 (*cdict).matchState.chainTable,
4589 chainSize,
4590 cdict_cParams,
4591 );
4592 }
4593 if ZSTD_rowMatchFinderUsed((*cdict_cParams).strategy, (*cdict).useRowMatchFinder) != 0 {
4594 let tagTableSize = hSize;
4595 libc::memcpy(
4596 (*cctx).blockState.matchState.tagTable as *mut core::ffi::c_void,
4597 (*cdict).matchState.tagTable as *const core::ffi::c_void,
4598 tagTableSize as libc::size_t,
4599 );
4600 (*cctx).blockState.matchState.hashSalt = (*cdict).matchState.hashSalt;
4601 }
4602 let h3log = (*cctx).blockState.matchState.hashLog3;
4603 let h3Size = if h3log != 0 {
4604 (1 as size_t) << h3log
4605 } else {
4606 0 as size_t
4607 };
4608 ptr::write_bytes(
4609 (*cctx).blockState.matchState.hashTable3 as *mut u8,
4610 0,
4611 h3Size.wrapping_mul(::core::mem::size_of::<u32>()),
4612 );
4613 ZSTD_cwksp_mark_tables_clean(&mut (*cctx).workspace);
4614 let srcMatchState: *const ZSTD_MatchState_t = &(*cdict).matchState;
4615 let dstMatchState: *mut ZSTD_MatchState_t = &mut (*cctx).blockState.matchState;
4616 (*dstMatchState).window = (*srcMatchState).window;
4617 (*dstMatchState).nextToUpdate = (*srcMatchState).nextToUpdate;
4618 (*dstMatchState).loadedDictEnd = (*srcMatchState).loadedDictEnd;
4619 (*cctx).dictID = (*cdict).dictID;
4620 (*cctx).dictContentSize = (*cdict).dictContentSize;
4621 libc::memcpy(
4622 (*cctx).blockState.prevCBlock as *mut core::ffi::c_void,
4623 &(*cdict).cBlockState as *const ZSTD_compressedBlockState_t as *const core::ffi::c_void,
4624 ::core::mem::size_of::<ZSTD_compressedBlockState_t>(),
4625 );
4626 0
4627}
4628unsafe fn ZSTD_resetCCtx_usingCDict(
4629 cctx: *mut ZSTD_CCtx,
4630 cdict: *const ZSTD_CDict,
4631 params: *const ZSTD_CCtx_params,
4632 pledgedSrcSize: u64,
4633 zbuff: ZSTD_buffered_policy_e,
4634) -> size_t {
4635 if ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize) != 0 {
4636 ZSTD_resetCCtx_byAttachingCDict(cctx, cdict, *params, pledgedSrcSize, zbuff)
4637 } else {
4638 ZSTD_resetCCtx_byCopyingCDict(cctx, cdict, *params, pledgedSrcSize, zbuff)
4639 }
4640}
4641unsafe fn ZSTD_copyCCtx_internal(
4642 dstCCtx: *mut ZSTD_CCtx,
4643 srcCCtx: *const ZSTD_CCtx,
4644 fParams: ZSTD_frameParameters,
4645 pledgedSrcSize: u64,
4646 zbuff: ZSTD_buffered_policy_e,
4647) -> size_t {
4648 if (*srcCCtx).stage as core::ffi::c_uint != ZSTDcs_init as core::ffi::c_int as core::ffi::c_uint
4649 {
4650 return Error::stage_wrong.to_error_code();
4651 }
4652 libc::memcpy(
4653 &mut (*dstCCtx).customMem as *mut ZSTD_customMem as *mut core::ffi::c_void,
4654 &(*srcCCtx).customMem as *const ZSTD_customMem as *const core::ffi::c_void,
4655 ::core::mem::size_of::<ZSTD_customMem>(),
4656 );
4657 let mut params = (*dstCCtx).requestedParams;
4658 params.cParams = (*srcCCtx).appliedParams.cParams;
4659 params.useRowMatchFinder = (*srcCCtx).appliedParams.useRowMatchFinder;
4660 params.postBlockSplitter = (*srcCCtx).appliedParams.postBlockSplitter;
4661 params.ldmParams = (*srcCCtx).appliedParams.ldmParams;
4662 params.fParams = fParams;
4663 params.maxBlockSize = (*srcCCtx).appliedParams.maxBlockSize;
4664 ZSTD_resetCCtx_internal(
4665 dstCCtx,
4666 ¶ms,
4667 pledgedSrcSize,
4668 0,
4669 ZSTDcrp_leaveDirty,
4670 zbuff,
4671 );
4672 ZSTD_cwksp_mark_tables_dirty(&mut (*dstCCtx).workspace);
4673 let chainSize = if ZSTD_allocateChainTable(
4674 (*srcCCtx).appliedParams.cParams.strategy,
4675 (*srcCCtx).appliedParams.useRowMatchFinder,
4676 0,
4677 ) != 0
4678 {
4679 (1 as size_t) << (*srcCCtx).appliedParams.cParams.chainLog
4680 } else {
4681 0 as size_t
4682 };
4683 let hSize = (1 as size_t) << (*srcCCtx).appliedParams.cParams.hashLog;
4684 let h3log = (*srcCCtx).blockState.matchState.hashLog3;
4685 let h3Size = if h3log != 0 {
4686 (1 as size_t) << h3log
4687 } else {
4688 0 as size_t
4689 };
4690 libc::memcpy(
4691 (*dstCCtx).blockState.matchState.hashTable as *mut core::ffi::c_void,
4692 (*srcCCtx).blockState.matchState.hashTable as *const core::ffi::c_void,
4693 hSize.wrapping_mul(::core::mem::size_of::<u32>()) as libc::size_t,
4694 );
4695 libc::memcpy(
4696 (*dstCCtx).blockState.matchState.chainTable as *mut core::ffi::c_void,
4697 (*srcCCtx).blockState.matchState.chainTable as *const core::ffi::c_void,
4698 chainSize.wrapping_mul(::core::mem::size_of::<u32>()) as libc::size_t,
4699 );
4700 libc::memcpy(
4701 (*dstCCtx).blockState.matchState.hashTable3 as *mut core::ffi::c_void,
4702 (*srcCCtx).blockState.matchState.hashTable3 as *const core::ffi::c_void,
4703 h3Size.wrapping_mul(::core::mem::size_of::<u32>()) as libc::size_t,
4704 );
4705 ZSTD_cwksp_mark_tables_clean(&mut (*dstCCtx).workspace);
4706 let srcMatchState: *const ZSTD_MatchState_t = &(*srcCCtx).blockState.matchState;
4707 let dstMatchState: *mut ZSTD_MatchState_t = &mut (*dstCCtx).blockState.matchState;
4708 (*dstMatchState).window = (*srcMatchState).window;
4709 (*dstMatchState).nextToUpdate = (*srcMatchState).nextToUpdate;
4710 (*dstMatchState).loadedDictEnd = (*srcMatchState).loadedDictEnd;
4711 (*dstCCtx).dictID = (*srcCCtx).dictID;
4712 (*dstCCtx).dictContentSize = (*srcCCtx).dictContentSize;
4713 libc::memcpy(
4714 (*dstCCtx).blockState.prevCBlock as *mut core::ffi::c_void,
4715 (*srcCCtx).blockState.prevCBlock as *const core::ffi::c_void,
4716 ::core::mem::size_of::<ZSTD_compressedBlockState_t>() as libc::size_t,
4717 );
4718 0
4719}
4720#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_copyCCtx))]
4721pub unsafe extern "C" fn ZSTD_copyCCtx(
4722 dstCCtx: *mut ZSTD_CCtx,
4723 srcCCtx: *const ZSTD_CCtx,
4724 mut pledgedSrcSize: core::ffi::c_ulonglong,
4725) -> size_t {
4726 let mut fParams = {
4727 ZSTD_frameParameters {
4728 contentSizeFlag: 1,
4729 checksumFlag: 0,
4730 noDictIDFlag: 0,
4731 }
4732 };
4733 let zbuff = (*srcCCtx).bufferedPolicy;
4734 if pledgedSrcSize == 0 {
4735 pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
4736 }
4737 fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN) as core::ffi::c_int;
4738 ZSTD_copyCCtx_internal(dstCCtx, srcCCtx, fParams, pledgedSrcSize, zbuff)
4739}
4740pub const ZSTD_ROWSIZE: core::ffi::c_int = 16;
4741#[inline(always)]
4742unsafe fn ZSTD_reduceTable_internal(
4743 table: *mut u32,
4744 size: u32,
4745 reducerValue: u32,
4746 preserveMark: core::ffi::c_int,
4747) {
4748 let nbRows = size as core::ffi::c_int / ZSTD_ROWSIZE;
4749 let mut cellNb = 0;
4750 let mut rowNb: core::ffi::c_int = 0;
4751 let reducerThreshold = reducerValue.wrapping_add(ZSTD_WINDOW_START_INDEX as u32);
4752 rowNb = 0;
4753 while rowNb < nbRows {
4754 let mut column: core::ffi::c_int = 0;
4755 column = 0;
4756 while column < ZSTD_ROWSIZE {
4757 let mut newVal: u32 = 0;
4758 if preserveMark != 0 && *table.offset(cellNb as isize) == ZSTD_DUBT_UNSORTED_MARK as u32
4759 {
4760 newVal = ZSTD_DUBT_UNSORTED_MARK as u32;
4761 } else if *table.offset(cellNb as isize) < reducerThreshold {
4762 newVal = 0;
4763 } else {
4764 newVal = (*table.offset(cellNb as isize)).wrapping_sub(reducerValue);
4765 }
4766 *table.offset(cellNb as isize) = newVal;
4767 cellNb += 1;
4768 column += 1;
4769 }
4770 rowNb += 1;
4771 }
4772}
4773unsafe fn ZSTD_reduceTable(table: *mut u32, size: u32, reducerValue: u32) {
4774 ZSTD_reduceTable_internal(table, size, reducerValue, 0);
4775}
4776unsafe fn ZSTD_reduceTable_btlazy2(table: *mut u32, size: u32, reducerValue: u32) {
4777 ZSTD_reduceTable_internal(table, size, reducerValue, 1);
4778}
4779unsafe fn ZSTD_reduceIndex(
4780 ms: *mut ZSTD_MatchState_t,
4781 params: *const ZSTD_CCtx_params,
4782 reducerValue: u32,
4783) {
4784 let hSize = (1) << (*params).cParams.hashLog;
4785 ZSTD_reduceTable((*ms).hashTable, hSize, reducerValue);
4786 if ZSTD_allocateChainTable(
4787 (*params).cParams.strategy,
4788 (*params).useRowMatchFinder,
4789 (*ms).dedicatedDictSearch as u32,
4790 ) != 0
4791 {
4792 let chainSize = (1) << (*params).cParams.chainLog;
4793 if (*params).cParams.strategy as core::ffi::c_uint
4794 == ZSTD_btlazy2 as core::ffi::c_int as core::ffi::c_uint
4795 {
4796 ZSTD_reduceTable_btlazy2((*ms).chainTable, chainSize, reducerValue);
4797 } else {
4798 ZSTD_reduceTable((*ms).chainTable, chainSize, reducerValue);
4799 }
4800 }
4801 if (*ms).hashLog3 != 0 {
4802 let h3Size = (1) << (*ms).hashLog3;
4803 ZSTD_reduceTable((*ms).hashTable3, h3Size, reducerValue);
4804 }
4805}
4806pub unsafe fn ZSTD_seqToCodes(seqStorePtr: *const SeqStore_t) -> core::ffi::c_int {
4807 let sequences: *const SeqDef = (*seqStorePtr).sequencesStart;
4808 let llCodeTable = (*seqStorePtr).llCode;
4809 let ofCodeTable = (*seqStorePtr).ofCode;
4810 let mlCodeTable = (*seqStorePtr).mlCode;
4811 let nbSeq = ((*seqStorePtr).sequences).offset_from((*seqStorePtr).sequencesStart)
4812 as core::ffi::c_long as u32;
4813 let mut u: u32 = 0;
4814 let mut longOffsets = 0;
4815 u = 0;
4816 while u < nbSeq {
4817 let llv = (*sequences.offset(u as isize)).litLength as u32;
4818 let ofCode = ZSTD_highbit32((*sequences.offset(u as isize)).offBase);
4819 let mlv = (*sequences.offset(u as isize)).mlBase as u32;
4820 *llCodeTable.offset(u as isize) = ZSTD_LLcode(llv) as u8;
4821 *ofCodeTable.offset(u as isize) = ofCode as u8;
4822 *mlCodeTable.offset(u as isize) = ZSTD_MLcode(mlv) as u8;
4823 if MEM_32bits() != 0
4824 && ofCode
4825 >= (if MEM_32bits() != 0 {
4826 STREAM_ACCUMULATOR_MIN_32
4827 } else {
4828 STREAM_ACCUMULATOR_MIN_64
4829 }) as u32
4830 {
4831 longOffsets = 1;
4832 }
4833 u = u.wrapping_add(1);
4834 }
4835 if (*seqStorePtr).longLengthType as core::ffi::c_uint
4836 == ZSTD_llt_literalLength as core::ffi::c_int as core::ffi::c_uint
4837 {
4838 *llCodeTable.offset((*seqStorePtr).longLengthPos as isize) = MaxLL as u8;
4839 }
4840 if (*seqStorePtr).longLengthType as core::ffi::c_uint
4841 == ZSTD_llt_matchLength as core::ffi::c_int as core::ffi::c_uint
4842 {
4843 *mlCodeTable.offset((*seqStorePtr).longLengthPos as isize) = MaxML as u8;
4844 }
4845 longOffsets
4846}
4847unsafe fn ZSTD_useTargetCBlockSize(cctxParams: *const ZSTD_CCtx_params) -> core::ffi::c_int {
4848 ((*cctxParams).targetCBlockSize != 0) as core::ffi::c_int
4849}
4850unsafe fn ZSTD_blockSplitterEnabled(cctxParams: *mut ZSTD_CCtx_params) -> core::ffi::c_int {
4851 ((*cctxParams).postBlockSplitter as core::ffi::c_uint
4852 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint) as core::ffi::c_int
4853}
4854unsafe fn ZSTD_buildSequencesStatistics(
4855 seqStorePtr: *const SeqStore_t,
4856 nbSeq: size_t,
4857 prevEntropy: *const ZSTD_fseCTables_t,
4858 nextEntropy: *mut ZSTD_fseCTables_t,
4859 dst: *mut u8,
4860 dstEnd: *const u8,
4861 strategy: ZSTD_strategy,
4862 countWorkspace: *mut core::ffi::c_uint,
4863 entropyWorkspace: *mut core::ffi::c_void,
4864 entropyWkspSize: size_t,
4865) -> ZSTD_symbolEncodingTypeStats_t {
4866 let ostart = dst;
4867 let oend = dstEnd;
4868 let mut op = ostart;
4869 let CTable_LitLength = ((*nextEntropy).litlengthCTable).as_mut_ptr();
4870 let CTable_OffsetBits = ((*nextEntropy).offcodeCTable).as_mut_ptr();
4871 let CTable_MatchLength = ((*nextEntropy).matchlengthCTable).as_mut_ptr();
4872 let ofCodeTable: *const u8 = (*seqStorePtr).ofCode;
4873 let llCodeTable: *const u8 = (*seqStorePtr).llCode;
4874 let mlCodeTable: *const u8 = (*seqStorePtr).mlCode;
4875 let mut stats = ZSTD_symbolEncodingTypeStats_t {
4876 LLtype: 0,
4877 Offtype: 0,
4878 MLtype: 0,
4879 size: 0,
4880 lastCountSize: 0,
4881 longOffsets: 0,
4882 };
4883 stats.lastCountSize = 0;
4884 stats.longOffsets = ZSTD_seqToCodes(seqStorePtr);
4885 let mut max = MaxLL as core::ffi::c_uint;
4886 let mostFrequent = HIST_countFast_wksp(
4887 countWorkspace,
4888 &mut max,
4889 llCodeTable as *const core::ffi::c_void,
4890 nbSeq,
4891 entropyWorkspace,
4892 entropyWkspSize,
4893 );
4894 (*nextEntropy).litlength_repeatMode = (*prevEntropy).litlength_repeatMode;
4895 stats.LLtype = ZSTD_selectEncodingType(
4896 &mut (*nextEntropy).litlength_repeatMode,
4897 countWorkspace,
4898 max,
4899 mostFrequent,
4900 nbSeq,
4901 LLFSELog as core::ffi::c_uint,
4902 ((*prevEntropy).litlengthCTable).as_ptr(),
4903 LL_defaultNorm.as_ptr(),
4904 LL_defaultNormLog,
4905 ZSTD_defaultAllowed,
4906 strategy,
4907 ) as u32;
4908 let countSize = ZSTD_buildCTable(
4909 op as *mut core::ffi::c_void,
4910 oend.offset_from(op) as size_t,
4911 CTable_LitLength,
4912 LLFSELog as u32,
4913 stats.LLtype as SymbolEncodingType_e,
4914 countWorkspace,
4915 max,
4916 llCodeTable,
4917 nbSeq,
4918 LL_defaultNorm.as_ptr(),
4919 LL_defaultNormLog,
4920 MaxLL as u32,
4921 ((*prevEntropy).litlengthCTable).as_ptr(),
4922 ::core::mem::size_of::<[FSE_CTable; 329]>(),
4923 entropyWorkspace,
4924 entropyWkspSize,
4925 );
4926 if ERR_isError(countSize) {
4927 stats.size = countSize;
4928 return stats;
4929 }
4930 if stats.LLtype == set_compressed as core::ffi::c_int as u32 {
4931 stats.lastCountSize = countSize;
4932 }
4933 op = op.add(countSize);
4934 let mut max_0 = MaxOff as core::ffi::c_uint;
4935 let mostFrequent_0 = HIST_countFast_wksp(
4936 countWorkspace,
4937 &mut max_0,
4938 ofCodeTable as *const core::ffi::c_void,
4939 nbSeq,
4940 entropyWorkspace,
4941 entropyWkspSize,
4942 );
4943 let defaultPolicy = (if max_0 <= DefaultMaxOff as core::ffi::c_uint {
4944 ZSTD_defaultAllowed as core::ffi::c_int
4945 } else {
4946 ZSTD_defaultDisallowed as core::ffi::c_int
4947 }) as ZSTD_DefaultPolicy_e;
4948 (*nextEntropy).offcode_repeatMode = (*prevEntropy).offcode_repeatMode;
4949 stats.Offtype = ZSTD_selectEncodingType(
4950 &mut (*nextEntropy).offcode_repeatMode,
4951 countWorkspace,
4952 max_0,
4953 mostFrequent_0,
4954 nbSeq,
4955 OffFSELog as core::ffi::c_uint,
4956 ((*prevEntropy).offcodeCTable).as_ptr(),
4957 OF_defaultNorm.as_ptr(),
4958 OF_defaultNormLog,
4959 defaultPolicy,
4960 strategy,
4961 ) as u32;
4962 let countSize_0 = ZSTD_buildCTable(
4963 op as *mut core::ffi::c_void,
4964 oend.offset_from(op) as size_t,
4965 CTable_OffsetBits,
4966 OffFSELog as u32,
4967 stats.Offtype as SymbolEncodingType_e,
4968 countWorkspace,
4969 max_0,
4970 ofCodeTable,
4971 nbSeq,
4972 OF_defaultNorm.as_ptr(),
4973 OF_defaultNormLog,
4974 DefaultMaxOff as u32,
4975 ((*prevEntropy).offcodeCTable).as_ptr(),
4976 ::core::mem::size_of::<[FSE_CTable; 193]>(),
4977 entropyWorkspace,
4978 entropyWkspSize,
4979 );
4980 if ERR_isError(countSize_0) {
4981 stats.size = countSize_0;
4982 return stats;
4983 }
4984 if stats.Offtype == set_compressed as core::ffi::c_int as u32 {
4985 stats.lastCountSize = countSize_0;
4986 }
4987 op = op.add(countSize_0);
4988 let mut max_1 = MaxML as core::ffi::c_uint;
4989 let mostFrequent_1 = HIST_countFast_wksp(
4990 countWorkspace,
4991 &mut max_1,
4992 mlCodeTable as *const core::ffi::c_void,
4993 nbSeq,
4994 entropyWorkspace,
4995 entropyWkspSize,
4996 );
4997 (*nextEntropy).matchlength_repeatMode = (*prevEntropy).matchlength_repeatMode;
4998 stats.MLtype = ZSTD_selectEncodingType(
4999 &mut (*nextEntropy).matchlength_repeatMode,
5000 countWorkspace,
5001 max_1,
5002 mostFrequent_1,
5003 nbSeq,
5004 MLFSELog as core::ffi::c_uint,
5005 ((*prevEntropy).matchlengthCTable).as_ptr(),
5006 ML_defaultNorm.as_ptr(),
5007 ML_defaultNormLog,
5008 ZSTD_defaultAllowed,
5009 strategy,
5010 ) as u32;
5011 let countSize_1 = ZSTD_buildCTable(
5012 op as *mut core::ffi::c_void,
5013 oend.offset_from(op) as size_t,
5014 CTable_MatchLength,
5015 MLFSELog as u32,
5016 stats.MLtype as SymbolEncodingType_e,
5017 countWorkspace,
5018 max_1,
5019 mlCodeTable,
5020 nbSeq,
5021 ML_defaultNorm.as_ptr(),
5022 ML_defaultNormLog,
5023 MaxML as u32,
5024 ((*prevEntropy).matchlengthCTable).as_ptr(),
5025 ::core::mem::size_of::<[FSE_CTable; 363]>(),
5026 entropyWorkspace,
5027 entropyWkspSize,
5028 );
5029 if ERR_isError(countSize_1) {
5030 stats.size = countSize_1;
5031 return stats;
5032 }
5033 if stats.MLtype == set_compressed as core::ffi::c_int as u32 {
5034 stats.lastCountSize = countSize_1;
5035 }
5036 op = op.add(countSize_1);
5037 stats.size = op.offset_from(ostart) as size_t;
5038 stats
5039}
5040pub const SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO: core::ffi::c_int = 20;
5041#[inline]
5042unsafe fn ZSTD_entropyCompressSeqStore_internal(
5043 dst: *mut core::ffi::c_void,
5044 dstCapacity: size_t,
5045 literals: *const core::ffi::c_void,
5046 litSize: size_t,
5047 seqStorePtr: *const SeqStore_t,
5048 prevEntropy: *const ZSTD_entropyCTables_t,
5049 nextEntropy: *mut ZSTD_entropyCTables_t,
5050 cctxParams: *const ZSTD_CCtx_params,
5051 mut entropyWorkspace: *mut core::ffi::c_void,
5052 mut entropyWkspSize: size_t,
5053 bmi2: core::ffi::c_int,
5054) -> size_t {
5055 let strategy = (*cctxParams).cParams.strategy;
5056 let count = entropyWorkspace as *mut core::ffi::c_uint;
5057 let CTable_LitLength = ((*nextEntropy).fse.litlengthCTable).as_mut_ptr();
5058 let CTable_OffsetBits = ((*nextEntropy).fse.offcodeCTable).as_mut_ptr();
5059 let CTable_MatchLength = ((*nextEntropy).fse.matchlengthCTable).as_mut_ptr();
5060 let sequences: *const SeqDef = (*seqStorePtr).sequencesStart;
5061 let nbSeq = ((*seqStorePtr).sequences).offset_from((*seqStorePtr).sequencesStart) as size_t;
5062 let ofCodeTable: *const u8 = (*seqStorePtr).ofCode;
5063 let llCodeTable: *const u8 = (*seqStorePtr).llCode;
5064 let mlCodeTable: *const u8 = (*seqStorePtr).mlCode;
5065 let ostart = dst as *mut u8;
5066 let oend = ostart.add(dstCapacity);
5067 let mut op = ostart;
5068 let mut lastCountSize: size_t = 0;
5069 let mut longOffsets = 0;
5070 entropyWorkspace =
5071 count.offset(((if 35 > 52 { 35 } else { 52 }) + 1) as isize) as *mut core::ffi::c_void;
5072 entropyWkspSize = (entropyWkspSize as size_t).wrapping_sub(
5073 ((if 35 > 52 { 35 as size_t } else { 52 }) + 1)
5074 .wrapping_mul(::core::mem::size_of::<core::ffi::c_uint>()),
5075 );
5076 let numSequences =
5077 ((*seqStorePtr).sequences).offset_from((*seqStorePtr).sequencesStart) as size_t;
5078 let suspectUncompressible = (numSequences == 0
5079 || litSize / numSequences >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO as size_t)
5080 as core::ffi::c_int;
5081 let cSize = ZSTD_compressLiterals(
5082 op as *mut core::ffi::c_void,
5083 dstCapacity,
5084 literals,
5085 litSize,
5086 entropyWorkspace,
5087 entropyWkspSize,
5088 &(*prevEntropy).huf,
5089 &mut (*nextEntropy).huf,
5090 (*cctxParams).cParams.strategy,
5091 ZSTD_literalsCompressionIsDisabled(cctxParams),
5092 suspectUncompressible,
5093 bmi2,
5094 );
5095 let err_code = cSize;
5096 if ERR_isError(err_code) {
5097 return err_code;
5098 }
5099 op = op.add(cSize);
5100 if (oend.offset_from(op) as core::ffi::c_long) < (3 + 1) as core::ffi::c_long {
5101 return Error::dstSize_tooSmall.to_error_code();
5102 }
5103 if nbSeq < 128 {
5104 let fresh2 = op;
5105 op = op.offset(1);
5106 *fresh2 = nbSeq as u8;
5107 } else if nbSeq < LONGNBSEQ as size_t {
5108 *op.offset(0) = (nbSeq >> 8).wrapping_add(0x80 as core::ffi::c_int as size_t) as u8;
5109 *op.offset(1) = nbSeq as u8;
5110 op = op.offset(2);
5111 } else {
5112 *op.offset(0) = 0xff as core::ffi::c_int as u8;
5113 MEM_writeLE16(
5114 op.offset(1) as *mut core::ffi::c_void,
5115 nbSeq.wrapping_sub(LONGNBSEQ as size_t) as u16,
5116 );
5117 op = op.offset(3);
5118 }
5119 if nbSeq == 0 {
5120 libc::memcpy(
5121 &mut (*nextEntropy).fse as *mut ZSTD_fseCTables_t as *mut core::ffi::c_void,
5122 &(*prevEntropy).fse as *const ZSTD_fseCTables_t as *const core::ffi::c_void,
5123 ::core::mem::size_of::<ZSTD_fseCTables_t>(),
5124 );
5125 return op.offset_from(ostart) as size_t;
5126 }
5127 let fresh3 = op;
5128 op = op.offset(1);
5129 let seqHead = fresh3;
5130 let stats = ZSTD_buildSequencesStatistics(
5131 seqStorePtr,
5132 nbSeq,
5133 &(*prevEntropy).fse,
5134 &mut (*nextEntropy).fse,
5135 op,
5136 oend,
5137 strategy,
5138 count,
5139 entropyWorkspace,
5140 entropyWkspSize,
5141 );
5142 let err_code_0 = stats.size;
5143 if ERR_isError(err_code_0) {
5144 return err_code_0;
5145 }
5146 *seqHead = (stats.LLtype << 6)
5147 .wrapping_add(stats.Offtype << 4)
5148 .wrapping_add(stats.MLtype << 2) as u8;
5149 lastCountSize = stats.lastCountSize;
5150 op = op.add(stats.size);
5151 longOffsets = stats.longOffsets;
5152 let bitstreamSize = ZSTD_encodeSequences(
5153 op as *mut core::ffi::c_void,
5154 oend.offset_from(op) as size_t,
5155 CTable_MatchLength,
5156 mlCodeTable,
5157 CTable_OffsetBits,
5158 ofCodeTable,
5159 CTable_LitLength,
5160 llCodeTable,
5161 sequences,
5162 nbSeq,
5163 longOffsets,
5164 bmi2,
5165 );
5166 let err_code_1 = bitstreamSize;
5167 if ERR_isError(err_code_1) {
5168 return err_code_1;
5169 }
5170 op = op.add(bitstreamSize);
5171 if lastCountSize != 0 && lastCountSize.wrapping_add(bitstreamSize) < 4 {
5172 return 0;
5173 }
5174 op.offset_from(ostart) as size_t
5175}
5176unsafe fn ZSTD_entropyCompressSeqStore_wExtLitBuffer(
5177 dst: *mut core::ffi::c_void,
5178 dstCapacity: size_t,
5179 literals: *const core::ffi::c_void,
5180 litSize: size_t,
5181 blockSize: size_t,
5182 seqStorePtr: *const SeqStore_t,
5183 prevEntropy: *const ZSTD_entropyCTables_t,
5184 nextEntropy: *mut ZSTD_entropyCTables_t,
5185 cctxParams: *const ZSTD_CCtx_params,
5186 entropyWorkspace: *mut core::ffi::c_void,
5187 entropyWkspSize: size_t,
5188 bmi2: core::ffi::c_int,
5189) -> size_t {
5190 let cSize = ZSTD_entropyCompressSeqStore_internal(
5191 dst,
5192 dstCapacity,
5193 literals,
5194 litSize,
5195 seqStorePtr,
5196 prevEntropy,
5197 nextEntropy,
5198 cctxParams,
5199 entropyWorkspace,
5200 entropyWkspSize,
5201 bmi2,
5202 );
5203 if cSize == 0 {
5204 return 0;
5205 }
5206 if (cSize == Error::dstSize_tooSmall.to_error_code()) as core::ffi::c_int
5207 & (blockSize <= dstCapacity) as core::ffi::c_int
5208 != 0
5209 {
5210 return 0;
5211 }
5212 let err_code = cSize;
5213 if ERR_isError(err_code) {
5214 return err_code;
5215 }
5216 let maxCSize = blockSize.wrapping_sub(ZSTD_minGain(blockSize, (*cctxParams).cParams.strategy));
5217 if cSize >= maxCSize {
5218 return 0;
5219 }
5220 cSize
5221}
5222unsafe fn ZSTD_entropyCompressSeqStore(
5223 seqStorePtr: *const SeqStore_t,
5224 prevEntropy: *const ZSTD_entropyCTables_t,
5225 nextEntropy: *mut ZSTD_entropyCTables_t,
5226 cctxParams: *const ZSTD_CCtx_params,
5227 dst: *mut core::ffi::c_void,
5228 dstCapacity: size_t,
5229 srcSize: size_t,
5230 entropyWorkspace: *mut core::ffi::c_void,
5231 entropyWkspSize: size_t,
5232 bmi2: core::ffi::c_int,
5233) -> size_t {
5234 ZSTD_entropyCompressSeqStore_wExtLitBuffer(
5235 dst,
5236 dstCapacity,
5237 (*seqStorePtr).litStart as *const core::ffi::c_void,
5238 ((*seqStorePtr).lit).offset_from((*seqStorePtr).litStart) as size_t,
5239 srcSize,
5240 seqStorePtr,
5241 prevEntropy,
5242 nextEntropy,
5243 cctxParams,
5244 entropyWorkspace,
5245 entropyWkspSize,
5246 bmi2,
5247 )
5248}
5249pub unsafe fn ZSTD_selectBlockCompressor(
5250 strat: ZSTD_strategy,
5251 useRowMatchFinder: ZSTD_ParamSwitch_e,
5252 dictMode: ZSTD_dictMode_e,
5253) -> ZSTD_BlockCompressor_f {
5254 static blockCompressor: [[ZSTD_BlockCompressor_f; 10]; 4] = [
5255 [
5256 Some(
5257 ZSTD_compressBlock_fast
5258 as unsafe fn(
5259 *mut ZSTD_MatchState_t,
5260 *mut SeqStore_t,
5261 *mut u32,
5262 *const core::ffi::c_void,
5263 size_t,
5264 ) -> size_t,
5265 ),
5266 Some(
5267 ZSTD_compressBlock_fast
5268 as unsafe fn(
5269 *mut ZSTD_MatchState_t,
5270 *mut SeqStore_t,
5271 *mut u32,
5272 *const core::ffi::c_void,
5273 size_t,
5274 ) -> size_t,
5275 ),
5276 Some(ZSTD_COMPRESSBLOCK_DOUBLEFAST),
5277 Some(ZSTD_COMPRESSBLOCK_GREEDY),
5278 Some(ZSTD_COMPRESSBLOCK_LAZY),
5279 Some(ZSTD_COMPRESSBLOCK_LAZY2),
5280 Some(ZSTD_COMPRESSBLOCK_BTLAZY2),
5281 Some(ZSTD_COMPRESSBLOCK_BTOPT),
5282 Some(ZSTD_COMPRESSBLOCK_BTULTRA),
5283 Some(ZSTD_COMPRESSBLOCK_BTULTRA2),
5284 ],
5285 [
5286 Some(
5287 ZSTD_compressBlock_fast_extDict
5288 as unsafe fn(
5289 *mut ZSTD_MatchState_t,
5290 *mut SeqStore_t,
5291 *mut u32,
5292 *const core::ffi::c_void,
5293 size_t,
5294 ) -> size_t,
5295 ),
5296 Some(
5297 ZSTD_compressBlock_fast_extDict
5298 as unsafe fn(
5299 *mut ZSTD_MatchState_t,
5300 *mut SeqStore_t,
5301 *mut u32,
5302 *const core::ffi::c_void,
5303 size_t,
5304 ) -> size_t,
5305 ),
5306 Some(ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT),
5307 Some(ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT),
5308 Some(ZSTD_COMPRESSBLOCK_LAZY_EXTDICT),
5309 Some(ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT),
5310 Some(ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT),
5311 Some(ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT),
5312 Some(ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT),
5313 Some(ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT),
5314 ],
5315 [
5316 Some(
5317 ZSTD_compressBlock_fast_dictMatchState
5318 as unsafe fn(
5319 *mut ZSTD_MatchState_t,
5320 *mut SeqStore_t,
5321 *mut u32,
5322 *const core::ffi::c_void,
5323 size_t,
5324 ) -> size_t,
5325 ),
5326 Some(
5327 ZSTD_compressBlock_fast_dictMatchState
5328 as unsafe fn(
5329 *mut ZSTD_MatchState_t,
5330 *mut SeqStore_t,
5331 *mut u32,
5332 *const core::ffi::c_void,
5333 size_t,
5334 ) -> size_t,
5335 ),
5336 Some(ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE),
5337 Some(ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE),
5338 Some(ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE),
5339 Some(ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE),
5340 Some(ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE),
5341 Some(ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE),
5342 Some(ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE),
5343 Some(ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE),
5344 ],
5345 [
5346 None,
5347 None,
5348 None,
5349 Some(ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH),
5350 Some(ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH),
5351 Some(ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH),
5352 None,
5353 None,
5354 None,
5355 None,
5356 ],
5357 ];
5358 let mut selectedCompressor: ZSTD_BlockCompressor_f = None;
5359 if ZSTD_rowMatchFinderUsed(strat, useRowMatchFinder) != 0 {
5360 static rowBasedBlockCompressors: [[ZSTD_BlockCompressor_f; 3]; 4] = [
5361 [
5362 Some(ZSTD_COMPRESSBLOCK_GREEDY_ROW),
5363 Some(ZSTD_COMPRESSBLOCK_LAZY_ROW),
5364 Some(ZSTD_COMPRESSBLOCK_LAZY2_ROW),
5365 ],
5366 [
5367 Some(ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW),
5368 Some(ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW),
5369 Some(ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW),
5370 ],
5371 [
5372 Some(ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW),
5373 Some(ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW),
5374 Some(ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW),
5375 ],
5376 [
5377 Some(ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW),
5378 Some(ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW),
5379 Some(ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW),
5380 ],
5381 ];
5382 selectedCompressor = *(*rowBasedBlockCompressors
5383 .as_ptr()
5384 .offset(dictMode as core::ffi::c_int as isize))
5385 .as_ptr()
5386 .offset((strat as core::ffi::c_int - ZSTD_greedy as core::ffi::c_int) as isize);
5387 } else {
5388 selectedCompressor = *(*blockCompressor
5389 .as_ptr()
5390 .offset(dictMode as core::ffi::c_int as isize))
5391 .as_ptr()
5392 .offset(strat as core::ffi::c_int as isize);
5393 }
5394 selectedCompressor
5395}
5396unsafe fn ZSTD_storeLastLiterals(
5397 seqStorePtr: *mut SeqStore_t,
5398 anchor: *const u8,
5399 lastLLSize: size_t,
5400) {
5401 libc::memcpy(
5402 (*seqStorePtr).lit as *mut core::ffi::c_void,
5403 anchor as *const core::ffi::c_void,
5404 lastLLSize as libc::size_t,
5405 );
5406 (*seqStorePtr).lit = ((*seqStorePtr).lit).add(lastLLSize);
5407}
5408pub unsafe fn ZSTD_resetSeqStore(ssPtr: *mut SeqStore_t) {
5409 (*ssPtr).lit = (*ssPtr).litStart;
5410 (*ssPtr).sequences = (*ssPtr).sequencesStart;
5411 (*ssPtr).longLengthType = ZSTD_llt_none;
5412}
5413unsafe fn ZSTD_postProcessSequenceProducerResult(
5414 outSeqs: *mut ZSTD_Sequence,
5415 nbExternalSeqs: size_t,
5416 outSeqsCapacity: size_t,
5417 srcSize: size_t,
5418) -> size_t {
5419 if nbExternalSeqs > outSeqsCapacity {
5420 return Error::sequenceProducer_failed.to_error_code();
5421 }
5422 if nbExternalSeqs == 0 && srcSize > 0 {
5423 return Error::sequenceProducer_failed.to_error_code();
5424 }
5425 if srcSize == 0 {
5426 ptr::write_bytes(
5427 &mut *outSeqs.offset(0) as *mut ZSTD_Sequence as *mut u8,
5428 0,
5429 ::core::mem::size_of::<ZSTD_Sequence>(),
5430 );
5431 return 1;
5432 }
5433 let lastSeq = *outSeqs.add(nbExternalSeqs.wrapping_sub(1));
5434 if lastSeq.offset == 0 && lastSeq.matchLength == 0 {
5435 return nbExternalSeqs;
5436 }
5437 if nbExternalSeqs == outSeqsCapacity {
5438 return Error::sequenceProducer_failed.to_error_code();
5439 }
5440 ptr::write_bytes(
5441 &mut *outSeqs.add(nbExternalSeqs) as *mut ZSTD_Sequence as *mut u8,
5442 0,
5443 ::core::mem::size_of::<ZSTD_Sequence>(),
5444 );
5445 nbExternalSeqs.wrapping_add(1)
5446}
5447unsafe fn ZSTD_fastSequenceLengthSum(seqBuf: *const ZSTD_Sequence, seqBufSize: size_t) -> size_t {
5448 let mut matchLenSum: size_t = 0;
5449 let mut litLenSum: size_t = 0;
5450 let mut i: size_t = 0;
5451 matchLenSum = 0;
5452 litLenSum = 0;
5453 i = 0;
5454 while i < seqBufSize {
5455 litLenSum = litLenSum.wrapping_add((*seqBuf.add(i)).litLength as size_t);
5456 matchLenSum = matchLenSum.wrapping_add((*seqBuf.add(i)).matchLength as size_t);
5457 i = i.wrapping_add(1);
5458 }
5459 litLenSum.wrapping_add(matchLenSum)
5460}
5461unsafe fn ZSTD_validateSeqStore(
5462 seqStore: *const SeqStore_t,
5463 cParams: *const ZSTD_compressionParameters,
5464) {
5465}
5466unsafe fn ZSTD_buildSeqStore(
5467 zc: *mut ZSTD_CCtx,
5468 src: *const core::ffi::c_void,
5469 srcSize: size_t,
5470) -> size_t {
5471 let ms: *mut ZSTD_MatchState_t = &mut (*zc).blockState.matchState;
5472 ZSTD_assertEqualCParams((*zc).appliedParams.cParams, (*ms).cParams);
5473 if srcSize
5474 < (MIN_CBLOCK_SIZE as size_t)
5475 .wrapping_add(ZSTD_blockHeaderSize)
5476 .wrapping_add(1)
5477 .wrapping_add(1)
5478 {
5479 if (*zc).appliedParams.cParams.strategy as core::ffi::c_uint
5480 >= ZSTD_btopt as core::ffi::c_int as core::ffi::c_uint
5481 {
5482 ZSTD_ldm_skipRawSeqStoreBytes(&mut (*zc).externSeqStore, srcSize);
5483 } else {
5484 ZSTD_ldm_skipSequences(
5485 &mut (*zc).externSeqStore,
5486 srcSize,
5487 (*zc).appliedParams.cParams.minMatch,
5488 );
5489 }
5490 return ZSTDbss_noCompress as core::ffi::c_int as size_t;
5491 }
5492 ZSTD_resetSeqStore(&mut (*zc).seqStore);
5493 (*ms).opt.symbolCosts = &mut (*(*zc).blockState.prevCBlock).entropy;
5494 (*ms).opt.literalCompressionMode = (*zc).appliedParams.literalCompressionMode;
5495 let base = (*ms).window.base;
5496 let istart = src as *const u8;
5497 let curr = istart.offset_from(base) as core::ffi::c_long as u32;
5498 ::core::mem::size_of::<ptrdiff_t>();
5499 8;
5500 if curr > ((*ms).nextToUpdate).wrapping_add(384) {
5501 (*ms).nextToUpdate = curr.wrapping_sub(
5502 if (192) < curr.wrapping_sub((*ms).nextToUpdate).wrapping_sub(384) {
5503 192
5504 } else {
5505 curr.wrapping_sub((*ms).nextToUpdate).wrapping_sub(384)
5506 },
5507 );
5508 }
5509 let dictMode = ZSTD_matchState_dictMode(ms);
5510 let mut lastLLSize: size_t = 0;
5511 let mut i: core::ffi::c_int = 0;
5512 i = 0;
5513 while i < ZSTD_REP_NUM {
5514 *((*(*zc).blockState.nextCBlock).rep)
5515 .as_mut_ptr()
5516 .offset(i as isize) = *((*(*zc).blockState.prevCBlock).rep)
5517 .as_mut_ptr()
5518 .offset(i as isize);
5519 i += 1;
5520 }
5521 if (*zc).externSeqStore.pos < (*zc).externSeqStore.size {
5522 if ZSTD_hasExtSeqProd(&(*zc).appliedParams) != 0 {
5523 return Error::parameter_combination_unsupported.to_error_code();
5524 }
5525 lastLLSize = ZSTD_ldm_blockCompress(
5526 &mut (*zc).externSeqStore,
5527 ms,
5528 &mut (*zc).seqStore,
5529 ((*(*zc).blockState.nextCBlock).rep).as_mut_ptr(),
5530 (*zc).appliedParams.useRowMatchFinder,
5531 src,
5532 srcSize,
5533 );
5534 } else if (*zc).appliedParams.ldmParams.enableLdm as core::ffi::c_uint
5535 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
5536 {
5537 let mut ldmSeqStore = kNullRawSeqStore;
5538 if ZSTD_hasExtSeqProd(&(*zc).appliedParams) != 0 {
5539 return Error::parameter_combination_unsupported.to_error_code();
5540 }
5541 ldmSeqStore.seq = (*zc).ldmSequences;
5542 ldmSeqStore.capacity = (*zc).maxNbLdmSequences;
5543 let err_code = ZSTD_ldm_generateSequences(
5544 &mut (*zc).ldmState,
5545 &mut ldmSeqStore,
5546 &(*zc).appliedParams.ldmParams,
5547 src,
5548 srcSize,
5549 );
5550 if ERR_isError(err_code) {
5551 return err_code;
5552 }
5553 lastLLSize = ZSTD_ldm_blockCompress(
5554 &mut ldmSeqStore,
5555 ms,
5556 &mut (*zc).seqStore,
5557 ((*(*zc).blockState.nextCBlock).rep).as_mut_ptr(),
5558 (*zc).appliedParams.useRowMatchFinder,
5559 src,
5560 srcSize,
5561 );
5562 } else if ZSTD_hasExtSeqProd(&(*zc).appliedParams) != 0 {
5563 let windowSize = (1) << (*zc).appliedParams.cParams.windowLog;
5564 let nbExternalSeqs = ((*zc).appliedParams.extSeqProdFunc).unwrap_unchecked()(
5565 (*zc).appliedParams.extSeqProdState,
5566 (*zc).extSeqBuf,
5567 (*zc).extSeqBufCapacity,
5568 src,
5569 srcSize,
5570 core::ptr::null(),
5571 0,
5572 (*zc).appliedParams.compressionLevel,
5573 windowSize as size_t,
5574 );
5575 let nbPostProcessedSeqs = ZSTD_postProcessSequenceProducerResult(
5576 (*zc).extSeqBuf,
5577 nbExternalSeqs,
5578 (*zc).extSeqBufCapacity,
5579 srcSize,
5580 );
5581 if !ERR_isError(nbPostProcessedSeqs) {
5582 let mut seqPos = {
5583 ZSTD_SequencePosition {
5584 idx: 0,
5585 posInSequence: 0,
5586 posInSrc: 0,
5587 }
5588 };
5589 let seqLenSum = ZSTD_fastSequenceLengthSum((*zc).extSeqBuf, nbPostProcessedSeqs);
5590 if seqLenSum > srcSize {
5591 return Error::externalSequences_invalid.to_error_code();
5592 }
5593 let err_code_0 = ZSTD_transferSequences_wBlockDelim(
5594 zc,
5595 &mut seqPos,
5596 (*zc).extSeqBuf,
5597 nbPostProcessedSeqs,
5598 src,
5599 srcSize,
5600 (*zc).appliedParams.searchForExternalRepcodes,
5601 );
5602 if ERR_isError(err_code_0) {
5603 return err_code_0;
5604 }
5605 (*ms).ldmSeqStore = core::ptr::null();
5606 return ZSTDbss_compress as core::ffi::c_int as size_t;
5607 }
5608 if (*zc).appliedParams.enableMatchFinderFallback == 0 {
5609 return nbPostProcessedSeqs;
5610 }
5611 let blockCompressor = ZSTD_selectBlockCompressor(
5612 (*zc).appliedParams.cParams.strategy,
5613 (*zc).appliedParams.useRowMatchFinder,
5614 dictMode,
5615 );
5616 (*ms).ldmSeqStore = core::ptr::null();
5617 lastLLSize = blockCompressor.unwrap_unchecked()(
5618 ms,
5619 &mut (*zc).seqStore,
5620 ((*(*zc).blockState.nextCBlock).rep).as_mut_ptr(),
5621 src,
5622 srcSize,
5623 );
5624 } else {
5625 let blockCompressor_0 = ZSTD_selectBlockCompressor(
5626 (*zc).appliedParams.cParams.strategy,
5627 (*zc).appliedParams.useRowMatchFinder,
5628 dictMode,
5629 );
5630 (*ms).ldmSeqStore = core::ptr::null();
5631 lastLLSize = blockCompressor_0.unwrap_unchecked()(
5632 ms,
5633 &mut (*zc).seqStore,
5634 ((*(*zc).blockState.nextCBlock).rep).as_mut_ptr(),
5635 src,
5636 srcSize,
5637 );
5638 }
5639 let lastLiterals = (src as *const u8)
5640 .add(srcSize)
5641 .offset(-(lastLLSize as isize));
5642 ZSTD_storeLastLiterals(&mut (*zc).seqStore, lastLiterals, lastLLSize);
5643 ZSTD_validateSeqStore(&(*zc).seqStore, &(*zc).appliedParams.cParams);
5644 ZSTDbss_compress as core::ffi::c_int as size_t
5645}
5646unsafe fn ZSTD_copyBlockSequences(
5647 seqCollector: *mut SeqCollector,
5648 seqStore: *const SeqStore_t,
5649 prevRepcodes: *const u32,
5650) -> size_t {
5651 let inSeqs: *const SeqDef = (*seqStore).sequencesStart;
5652 let nbInSequences = ((*seqStore).sequences).offset_from(inSeqs) as size_t;
5653 let nbInLiterals = ((*seqStore).lit).offset_from((*seqStore).litStart) as size_t;
5654 let outSeqs = if (*seqCollector).seqIndex == 0 {
5655 (*seqCollector).seqStart
5656 } else {
5657 ((*seqCollector).seqStart).add((*seqCollector).seqIndex)
5658 };
5659 let nbOutSequences = nbInSequences.wrapping_add(1);
5660 let mut nbOutLiterals = 0 as size_t;
5661 let mut repcodes = repcodes_s { rep: [0; 3] };
5662 let mut i: size_t = 0;
5663 if nbOutSequences > ((*seqCollector).maxSequences).wrapping_sub((*seqCollector).seqIndex) {
5664 return Error::dstSize_tooSmall.to_error_code();
5665 }
5666 libc::memcpy(
5667 &mut repcodes as *mut Repcodes_t as *mut core::ffi::c_void,
5668 prevRepcodes as *const core::ffi::c_void,
5669 ::core::mem::size_of::<Repcodes_t>(),
5670 );
5671 i = 0;
5672 while i < nbInSequences {
5673 let mut rawOffset: u32 = 0;
5674 (*outSeqs.add(i)).litLength = (*inSeqs.add(i)).litLength as core::ffi::c_uint;
5675 (*outSeqs.add(i)).matchLength =
5676 ((*inSeqs.add(i)).mlBase as core::ffi::c_int + MINMATCH) as core::ffi::c_uint;
5677 (*outSeqs.add(i)).rep = 0;
5678 if i == (*seqStore).longLengthPos as size_t {
5679 if (*seqStore).longLengthType as core::ffi::c_uint
5680 == ZSTD_llt_literalLength as core::ffi::c_int as core::ffi::c_uint
5681 {
5682 let fresh4 = &mut (*outSeqs.add(i)).litLength;
5683 *fresh4 = (*fresh4).wrapping_add(0x10000 as core::ffi::c_int as core::ffi::c_uint);
5684 } else if (*seqStore).longLengthType as core::ffi::c_uint
5685 == ZSTD_llt_matchLength as core::ffi::c_int as core::ffi::c_uint
5686 {
5687 let fresh5 = &mut (*outSeqs.add(i)).matchLength;
5688 *fresh5 = (*fresh5).wrapping_add(0x10000 as core::ffi::c_int as core::ffi::c_uint);
5689 }
5690 }
5691 if 1 <= (*inSeqs.add(i)).offBase && (*inSeqs.add(i)).offBase <= ZSTD_REP_NUM as u32 {
5692 let repcode = (*inSeqs.add(i)).offBase;
5693 (*outSeqs.add(i)).rep = repcode;
5694 if (*outSeqs.add(i)).litLength != 0 {
5695 rawOffset = *(repcodes.rep)
5696 .as_mut_ptr()
5697 .offset(repcode.wrapping_sub(1) as isize);
5698 } else if repcode == 3 {
5699 rawOffset = (*(repcodes.rep).as_mut_ptr().offset(0)).wrapping_sub(1);
5700 } else {
5701 rawOffset = *(repcodes.rep).as_mut_ptr().offset(repcode as isize);
5702 }
5703 } else {
5704 rawOffset = ((*inSeqs.add(i)).offBase).wrapping_sub(ZSTD_REP_NUM as u32);
5705 }
5706 (*outSeqs.add(i)).offset = rawOffset;
5707 ZSTD_updateRep(
5708 (repcodes.rep).as_mut_ptr(),
5709 (*inSeqs.add(i)).offBase,
5710 ((*inSeqs.add(i)).litLength as core::ffi::c_int == 0) as core::ffi::c_int as u32,
5711 );
5712 nbOutLiterals = nbOutLiterals.wrapping_add((*outSeqs.add(i)).litLength as size_t);
5713 i = i.wrapping_add(1);
5714 }
5715 let lastLLSize = nbInLiterals.wrapping_sub(nbOutLiterals);
5716 (*outSeqs.add(nbInSequences)).litLength = lastLLSize as u32;
5717 (*outSeqs.add(nbInSequences)).matchLength = 0;
5718 (*outSeqs.add(nbInSequences)).offset = 0;
5719 (*seqCollector).seqIndex = ((*seqCollector).seqIndex).wrapping_add(nbOutSequences);
5720 0
5721}
5722#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_sequenceBound))]
5723pub unsafe extern "C" fn ZSTD_sequenceBound(srcSize: size_t) -> size_t {
5724 let maxNbSeq = (srcSize / ZSTD_MINMATCH_MIN as size_t).wrapping_add(1);
5725 let maxNbDelims = (srcSize / ZSTD_BLOCKSIZE_MAX_MIN as size_t).wrapping_add(1);
5726 maxNbSeq.wrapping_add(maxNbDelims)
5727}
5728#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_generateSequences))]
5729pub unsafe extern "C" fn ZSTD_generateSequences(
5730 zc: *mut ZSTD_CCtx,
5731 outSeqs: *mut ZSTD_Sequence,
5732 outSeqsSize: size_t,
5733 src: *const core::ffi::c_void,
5734 srcSize: size_t,
5735) -> size_t {
5736 let dstCapacity = ZSTD_compressBound(srcSize);
5737 let mut dst = core::ptr::null_mut::<core::ffi::c_void>();
5738 let mut seqCollector = SeqCollector {
5739 collectSequences: 0,
5740 seqStart: core::ptr::null_mut::<ZSTD_Sequence>(),
5741 seqIndex: 0,
5742 maxSequences: 0,
5743 };
5744 let mut targetCBlockSize: core::ffi::c_int = 0;
5745 let err_code = ZSTD_CCtx_getParameter(zc, ZSTD_c_targetCBlockSize, &mut targetCBlockSize);
5746 if ERR_isError(err_code) {
5747 return err_code;
5748 }
5749 if targetCBlockSize != 0 {
5750 return Error::parameter_unsupported.to_error_code();
5751 }
5752 let mut nbWorkers: core::ffi::c_int = 0;
5753 let err_code_0 = ZSTD_CCtx_getParameter(zc, ZSTD_c_nbWorkers, &mut nbWorkers);
5754 if ERR_isError(err_code_0) {
5755 return err_code_0;
5756 }
5757 if nbWorkers != 0 {
5758 return Error::parameter_unsupported.to_error_code();
5759 }
5760 dst = ZSTD_customMalloc(dstCapacity, ZSTD_defaultCMem);
5761 if dst.is_null() {
5762 return Error::memory_allocation.to_error_code();
5763 }
5764 seqCollector.collectSequences = 1;
5765 seqCollector.seqStart = outSeqs;
5766 seqCollector.seqIndex = 0;
5767 seqCollector.maxSequences = outSeqsSize;
5768 (*zc).seqCollector = seqCollector;
5769 let ret = ZSTD_compress2(zc, dst, dstCapacity, src, srcSize);
5770 ZSTD_customFree(dst, ZSTD_defaultCMem);
5771 let err_code_1 = ret;
5772 if ERR_isError(err_code_1) {
5773 return err_code_1;
5774 }
5775 (*zc).seqCollector.seqIndex
5776}
5777#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_mergeBlockDelimiters))]
5778pub unsafe extern "C" fn ZSTD_mergeBlockDelimiters(
5779 sequences: *mut ZSTD_Sequence,
5780 seqsSize: size_t,
5781) -> size_t {
5782 let mut in_0 = 0;
5783 let mut out = 0 as size_t;
5784 while in_0 < seqsSize {
5785 if (*sequences.add(in_0)).offset == 0 && (*sequences.add(in_0)).matchLength == 0 {
5786 if in_0 != seqsSize.wrapping_sub(1) {
5787 let fresh6 = &mut (*sequences.add(in_0.wrapping_add(1))).litLength;
5788 *fresh6 = (*fresh6).wrapping_add((*sequences.add(in_0)).litLength);
5789 }
5790 } else {
5791 *sequences.add(out) = *sequences.add(in_0);
5792 out = out.wrapping_add(1);
5793 }
5794 in_0 = in_0.wrapping_add(1);
5795 }
5796 out
5797}
5798unsafe fn ZSTD_isRLE(src: *const u8, length: size_t) -> core::ffi::c_int {
5799 let ip = src;
5800 let value = *ip.offset(0);
5801 let valueST = (value as u64 as core::ffi::c_ulonglong)
5802 .wrapping_mul(0x101010101010101 as core::ffi::c_ulonglong) as size_t;
5803 let unrollSize = ::core::mem::size_of::<size_t>().wrapping_mul(4);
5804 let unrollMask = unrollSize.wrapping_sub(1);
5805 let prefixLength = length & unrollMask;
5806 let mut i: size_t = 0;
5807 if length == 1 {
5808 return 1;
5809 }
5810 if prefixLength != 0
5811 && ZSTD_count(ip.offset(1), ip, ip.add(prefixLength)) != prefixLength.wrapping_sub(1)
5812 {
5813 return 0;
5814 }
5815 i = prefixLength;
5816 while i != length {
5817 let mut u: size_t = 0;
5818 u = 0;
5819 while u < unrollSize {
5820 if MEM_readST(ip.add(i).add(u) as *const core::ffi::c_void) != valueST {
5821 return 0;
5822 }
5823 u = (u as size_t).wrapping_add(::core::mem::size_of::<size_t>());
5824 }
5825 i = i.wrapping_add(unrollSize);
5826 }
5827 1
5828}
5829unsafe fn ZSTD_maybeRLE(seqStore: *const SeqStore_t) -> core::ffi::c_int {
5830 let nbSeqs = ((*seqStore).sequences).offset_from((*seqStore).sequencesStart) as size_t;
5831 let nbLits = ((*seqStore).lit).offset_from((*seqStore).litStart) as size_t;
5832 (nbSeqs < 4 && nbLits < 10) as core::ffi::c_int
5833}
5834unsafe fn ZSTD_blockState_confirmRepcodesAndEntropyTables(bs: *mut ZSTD_blockState_t) {
5835 core::mem::swap(&mut (*bs).prevCBlock, &mut (*bs).nextCBlock);
5836}
5837unsafe fn writeBlockHeader(
5838 op: *mut core::ffi::c_void,
5839 cSize: size_t,
5840 blockSize: size_t,
5841 lastBlock: u32,
5842) {
5843 let cBlockHeader = if cSize == 1 {
5844 lastBlock
5845 .wrapping_add((bt_rle as core::ffi::c_int as u32) << 1)
5846 .wrapping_add((blockSize << 3) as u32)
5847 } else {
5848 lastBlock
5849 .wrapping_add((bt_compressed as core::ffi::c_int as u32) << 1)
5850 .wrapping_add((cSize << 3) as u32)
5851 };
5852 MEM_writeLE24(op, cBlockHeader);
5853}
5854unsafe fn ZSTD_buildBlockEntropyStats_literals(
5855 src: *mut core::ffi::c_void,
5856 srcSize: size_t,
5857 prevHuf: *const ZSTD_hufCTables_t,
5858 nextHuf: *mut ZSTD_hufCTables_t,
5859 hufMetadata: *mut ZSTD_hufCTablesMetadata_t,
5860 literalsCompressionIsDisabled: core::ffi::c_int,
5861 workspace: *mut core::ffi::c_void,
5862 wkspSize: size_t,
5863 hufFlags: core::ffi::c_int,
5864) -> size_t {
5865 let wkspStart = workspace as *mut u8;
5866 let wkspEnd = wkspStart.add(wkspSize);
5867 let countWkspStart = wkspStart;
5868 let countWksp = workspace as *mut core::ffi::c_uint;
5869 let countWkspSize = ((HUF_SYMBOLVALUE_MAX + 1) as size_t)
5870 .wrapping_mul(::core::mem::size_of::<core::ffi::c_uint>());
5871 let nodeWksp = countWkspStart.add(countWkspSize);
5872 let nodeWkspSize = wkspEnd.offset_from(nodeWksp) as size_t;
5873 let mut maxSymbolValue = HUF_SYMBOLVALUE_MAX as core::ffi::c_uint;
5874 let mut huffLog = LitHufLog as core::ffi::c_uint;
5875 let mut repeat = (*prevHuf).repeatMode;
5876 libc::memcpy(
5877 nextHuf as *mut core::ffi::c_void,
5878 prevHuf as *const core::ffi::c_void,
5879 ::core::mem::size_of::<ZSTD_hufCTables_t>(),
5880 );
5881 if literalsCompressionIsDisabled != 0 {
5882 (*hufMetadata).hType = set_basic;
5883 return 0;
5884 }
5885 let minLitSize = (if (*prevHuf).repeatMode as core::ffi::c_uint
5886 == HUF_repeat_valid as core::ffi::c_int as core::ffi::c_uint
5887 {
5888 6
5889 } else {
5890 COMPRESS_LITERALS_SIZE_MIN
5891 }) as size_t;
5892 if srcSize <= minLitSize {
5893 (*hufMetadata).hType = set_basic;
5894 return 0;
5895 }
5896 let largest = HIST_count_wksp(
5897 countWksp,
5898 &mut maxSymbolValue,
5899 src as *const u8 as *const core::ffi::c_void,
5900 srcSize,
5901 workspace,
5902 wkspSize,
5903 );
5904 let err_code = largest;
5905 if ERR_isError(err_code) {
5906 return err_code;
5907 }
5908 if largest == srcSize {
5909 (*hufMetadata).hType = set_rle;
5910 return 0;
5911 }
5912 if largest <= (srcSize >> 7).wrapping_add(4) {
5913 (*hufMetadata).hType = set_basic;
5914 return 0;
5915 }
5916 if repeat as core::ffi::c_uint == HUF_repeat_check as core::ffi::c_int as core::ffi::c_uint
5917 && HUF_validateCTable(((*prevHuf).CTable).as_ptr(), countWksp, maxSymbolValue) == 0
5918 {
5919 repeat = HUF_repeat_none;
5920 }
5921 ptr::write_bytes(
5922 ((*nextHuf).CTable).as_mut_ptr() as *mut u8,
5923 0,
5924 ::core::mem::size_of::<[HUF_CElt; 257]>(),
5925 );
5926 huffLog = HUF_optimalTableLog(
5927 huffLog,
5928 srcSize,
5929 maxSymbolValue,
5930 nodeWksp as *mut core::ffi::c_void,
5931 nodeWkspSize,
5932 ((*nextHuf).CTable).as_mut_ptr(),
5933 countWksp,
5934 hufFlags,
5935 );
5936 let maxBits = HUF_buildCTable_wksp(
5937 ((*nextHuf).CTable).as_mut_ptr(),
5938 countWksp,
5939 maxSymbolValue,
5940 huffLog,
5941 nodeWksp as *mut core::ffi::c_void,
5942 nodeWkspSize,
5943 );
5944 let err_code_0 = maxBits;
5945 if ERR_isError(err_code_0) {
5946 return err_code_0;
5947 }
5948 huffLog = maxBits as u32;
5949 let newCSize =
5950 HUF_estimateCompressedSize(((*nextHuf).CTable).as_mut_ptr(), countWksp, maxSymbolValue);
5951 let hSize = HUF_writeCTable_wksp(
5952 ((*hufMetadata).hufDesBuffer).as_mut_ptr() as *mut core::ffi::c_void,
5953 ::core::mem::size_of::<[u8; 128]>(),
5954 ((*nextHuf).CTable).as_mut_ptr(),
5955 maxSymbolValue,
5956 huffLog,
5957 nodeWksp as *mut core::ffi::c_void,
5958 nodeWkspSize,
5959 );
5960 if repeat as core::ffi::c_uint != HUF_repeat_none as core::ffi::c_int as core::ffi::c_uint {
5961 let oldCSize =
5962 HUF_estimateCompressedSize(((*prevHuf).CTable).as_ptr(), countWksp, maxSymbolValue);
5963 if oldCSize < srcSize
5964 && (oldCSize <= hSize.wrapping_add(newCSize) || hSize.wrapping_add(12) >= srcSize)
5965 {
5966 libc::memcpy(
5967 nextHuf as *mut core::ffi::c_void,
5968 prevHuf as *const core::ffi::c_void,
5969 ::core::mem::size_of::<ZSTD_hufCTables_t>(),
5970 );
5971 (*hufMetadata).hType = set_repeat;
5972 return 0;
5973 }
5974 }
5975 if newCSize.wrapping_add(hSize) >= srcSize {
5976 libc::memcpy(
5977 nextHuf as *mut core::ffi::c_void,
5978 prevHuf as *const core::ffi::c_void,
5979 ::core::mem::size_of::<ZSTD_hufCTables_t>(),
5980 );
5981 (*hufMetadata).hType = set_basic;
5982 return 0;
5983 }
5984 (*hufMetadata).hType = set_compressed;
5985 (*nextHuf).repeatMode = HUF_repeat_check;
5986 hSize
5987}
5988pub const COMPRESS_LITERALS_SIZE_MIN: core::ffi::c_int = 63;
5989unsafe fn ZSTD_buildDummySequencesStatistics(
5990 nextEntropy: *mut ZSTD_fseCTables_t,
5991) -> ZSTD_symbolEncodingTypeStats_t {
5992 let stats = {
5993 ZSTD_symbolEncodingTypeStats_t {
5994 LLtype: set_basic as core::ffi::c_int as u32,
5995 Offtype: set_basic as core::ffi::c_int as u32,
5996 MLtype: set_basic as core::ffi::c_int as u32,
5997 size: 0,
5998 lastCountSize: 0,
5999 longOffsets: 0,
6000 }
6001 };
6002 (*nextEntropy).litlength_repeatMode = FSE_repeat_none;
6003 (*nextEntropy).offcode_repeatMode = FSE_repeat_none;
6004 (*nextEntropy).matchlength_repeatMode = FSE_repeat_none;
6005 stats
6006}
6007unsafe fn ZSTD_buildBlockEntropyStats_sequences(
6008 seqStorePtr: *const SeqStore_t,
6009 prevEntropy: *const ZSTD_fseCTables_t,
6010 nextEntropy: *mut ZSTD_fseCTables_t,
6011 cctxParams: *const ZSTD_CCtx_params,
6012 fseMetadata: *mut ZSTD_fseCTablesMetadata_t,
6013 workspace: *mut core::ffi::c_void,
6014 wkspSize: size_t,
6015) -> size_t {
6016 let strategy = (*cctxParams).cParams.strategy;
6017 let nbSeq = ((*seqStorePtr).sequences).offset_from((*seqStorePtr).sequencesStart) as size_t;
6018 let ostart = ((*fseMetadata).fseTablesBuffer).as_mut_ptr();
6019 let oend = ostart.add(::core::mem::size_of::<[u8; 133]>());
6020 let op = ostart;
6021 let countWorkspace = workspace as *mut core::ffi::c_uint;
6022 let entropyWorkspace = countWorkspace.offset(((if 35 > 52 { 35 } else { 52 }) + 1) as isize);
6023 let entropyWorkspaceSize = wkspSize.wrapping_sub(
6024 ((if 35 > 52 { 35 as size_t } else { 52 }) + 1)
6025 .wrapping_mul(::core::mem::size_of::<core::ffi::c_uint>()),
6026 );
6027 let mut stats = ZSTD_symbolEncodingTypeStats_t {
6028 LLtype: 0,
6029 Offtype: 0,
6030 MLtype: 0,
6031 size: 0,
6032 lastCountSize: 0,
6033 longOffsets: 0,
6034 };
6035 stats = if nbSeq != 0 {
6036 ZSTD_buildSequencesStatistics(
6037 seqStorePtr,
6038 nbSeq,
6039 prevEntropy,
6040 nextEntropy,
6041 op,
6042 oend,
6043 strategy,
6044 countWorkspace,
6045 entropyWorkspace as *mut core::ffi::c_void,
6046 entropyWorkspaceSize,
6047 )
6048 } else {
6049 ZSTD_buildDummySequencesStatistics(nextEntropy)
6050 };
6051 let err_code = stats.size;
6052 if ERR_isError(err_code) {
6053 return err_code;
6054 }
6055 (*fseMetadata).llType = stats.LLtype as SymbolEncodingType_e;
6056 (*fseMetadata).ofType = stats.Offtype as SymbolEncodingType_e;
6057 (*fseMetadata).mlType = stats.MLtype as SymbolEncodingType_e;
6058 (*fseMetadata).lastCountSize = stats.lastCountSize;
6059 stats.size
6060}
6061pub unsafe fn ZSTD_buildBlockEntropyStats(
6062 seqStorePtr: *const SeqStore_t,
6063 prevEntropy: *const ZSTD_entropyCTables_t,
6064 nextEntropy: *mut ZSTD_entropyCTables_t,
6065 cctxParams: *const ZSTD_CCtx_params,
6066 entropyMetadata: *mut ZSTD_entropyCTablesMetadata_t,
6067 workspace: *mut core::ffi::c_void,
6068 wkspSize: size_t,
6069) -> size_t {
6070 let litSize = ((*seqStorePtr).lit).offset_from((*seqStorePtr).litStart) as size_t;
6071 let huf_useOptDepth = ((*cctxParams).cParams.strategy as core::ffi::c_uint
6072 >= HUF_OPTIMAL_DEPTH_THRESHOLD as core::ffi::c_uint)
6073 as core::ffi::c_int;
6074 let hufFlags = if huf_useOptDepth != 0 {
6075 HUF_flags_optimalDepth as core::ffi::c_int
6076 } else {
6077 0
6078 };
6079 (*entropyMetadata).hufMetadata.hufDesSize = ZSTD_buildBlockEntropyStats_literals(
6080 (*seqStorePtr).litStart as *mut core::ffi::c_void,
6081 litSize,
6082 &(*prevEntropy).huf,
6083 &mut (*nextEntropy).huf,
6084 &mut (*entropyMetadata).hufMetadata,
6085 ZSTD_literalsCompressionIsDisabled(cctxParams),
6086 workspace,
6087 wkspSize,
6088 hufFlags,
6089 );
6090 let err_code = (*entropyMetadata).hufMetadata.hufDesSize;
6091 if ERR_isError(err_code) {
6092 return err_code;
6093 }
6094 (*entropyMetadata).fseMetadata.fseTablesSize = ZSTD_buildBlockEntropyStats_sequences(
6095 seqStorePtr,
6096 &(*prevEntropy).fse,
6097 &mut (*nextEntropy).fse,
6098 cctxParams,
6099 &mut (*entropyMetadata).fseMetadata,
6100 workspace,
6101 wkspSize,
6102 );
6103 let err_code_0 = (*entropyMetadata).fseMetadata.fseTablesSize;
6104 if ERR_isError(err_code_0) {
6105 return err_code_0;
6106 }
6107 0
6108}
6109unsafe fn ZSTD_estimateBlockSize_literal(
6110 literals: *const u8,
6111 litSize: size_t,
6112 huf: *const ZSTD_hufCTables_t,
6113 hufMetadata: *const ZSTD_hufCTablesMetadata_t,
6114 workspace: *mut core::ffi::c_void,
6115 wkspSize: size_t,
6116 writeEntropy: core::ffi::c_int,
6117) -> size_t {
6118 let countWksp = workspace as *mut core::ffi::c_uint;
6119 let mut maxSymbolValue = HUF_SYMBOLVALUE_MAX as core::ffi::c_uint;
6120 let literalSectionHeaderSize =
6121 (3 + (litSize >= ((1) << 10) as size_t) as core::ffi::c_int
6122 + (litSize >= (16 * ((1) << 10)) as size_t) as core::ffi::c_int) as size_t;
6123 let singleStream = (litSize < 256) as core::ffi::c_int as u32;
6124 if (*hufMetadata).hType as core::ffi::c_uint
6125 == set_basic as core::ffi::c_int as core::ffi::c_uint
6126 {
6127 return litSize;
6128 } else if (*hufMetadata).hType as core::ffi::c_uint
6129 == set_rle as core::ffi::c_int as core::ffi::c_uint
6130 {
6131 return 1;
6132 } else if (*hufMetadata).hType as core::ffi::c_uint
6133 == set_compressed as core::ffi::c_int as core::ffi::c_uint
6134 || (*hufMetadata).hType as core::ffi::c_uint
6135 == set_repeat as core::ffi::c_int as core::ffi::c_uint
6136 {
6137 let largest = HIST_count_wksp(
6138 countWksp,
6139 &mut maxSymbolValue,
6140 literals as *const core::ffi::c_void,
6141 litSize,
6142 workspace,
6143 wkspSize,
6144 );
6145 if ERR_isError(largest) {
6146 return litSize;
6147 }
6148 let mut cLitSizeEstimate =
6149 HUF_estimateCompressedSize(((*huf).CTable).as_ptr(), countWksp, maxSymbolValue);
6150 if writeEntropy != 0 {
6151 cLitSizeEstimate = cLitSizeEstimate.wrapping_add((*hufMetadata).hufDesSize);
6152 }
6153 if singleStream == 0 {
6154 cLitSizeEstimate = cLitSizeEstimate.wrapping_add(6);
6155 }
6156 return cLitSizeEstimate.wrapping_add(literalSectionHeaderSize);
6157 }
6158 0
6159}
6160unsafe fn ZSTD_estimateBlockSize_symbolType(
6161 type_0: SymbolEncodingType_e,
6162 codeTable: *const u8,
6163 nbSeq: size_t,
6164 maxCode: core::ffi::c_uint,
6165 fseCTable: *const FSE_CTable,
6166 additionalBits: *const u8,
6167 defaultNorm: *const core::ffi::c_short,
6168 defaultNormLog: u32,
6169 defaultMax: u32,
6170 workspace: *mut core::ffi::c_void,
6171 wkspSize: size_t,
6172) -> size_t {
6173 let countWksp = workspace as *mut core::ffi::c_uint;
6174 let mut ctp = codeTable;
6175 let ctStart = ctp;
6176 let ctEnd = ctStart.add(nbSeq);
6177 let mut cSymbolTypeSizeEstimateInBits = 0;
6178 let mut max = maxCode;
6179 HIST_countFast_wksp(
6180 countWksp,
6181 &mut max,
6182 codeTable as *const core::ffi::c_void,
6183 nbSeq,
6184 workspace,
6185 wkspSize,
6186 );
6187 if type_0 as core::ffi::c_uint == set_basic as core::ffi::c_int as core::ffi::c_uint {
6188 cSymbolTypeSizeEstimateInBits =
6189 ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max);
6190 } else if type_0 as core::ffi::c_uint == set_rle as core::ffi::c_int as core::ffi::c_uint {
6191 cSymbolTypeSizeEstimateInBits = 0;
6192 } else if type_0 as core::ffi::c_uint == set_compressed as core::ffi::c_int as core::ffi::c_uint
6193 || type_0 as core::ffi::c_uint == set_repeat as core::ffi::c_int as core::ffi::c_uint
6194 {
6195 cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);
6196 }
6197 if ERR_isError(cSymbolTypeSizeEstimateInBits) {
6198 return nbSeq * 10;
6199 }
6200 while ctp < ctEnd {
6201 if !additionalBits.is_null() {
6202 cSymbolTypeSizeEstimateInBits = cSymbolTypeSizeEstimateInBits
6203 .wrapping_add(*additionalBits.offset(*ctp as isize) as size_t);
6204 } else {
6205 cSymbolTypeSizeEstimateInBits =
6206 cSymbolTypeSizeEstimateInBits.wrapping_add(*ctp as size_t);
6207 }
6208 ctp = ctp.offset(1);
6209 }
6210 cSymbolTypeSizeEstimateInBits >> 3
6211}
6212unsafe fn ZSTD_estimateBlockSize_sequences(
6213 ofCodeTable: *const u8,
6214 llCodeTable: *const u8,
6215 mlCodeTable: *const u8,
6216 nbSeq: size_t,
6217 fseTables: *const ZSTD_fseCTables_t,
6218 fseMetadata: *const ZSTD_fseCTablesMetadata_t,
6219 workspace: *mut core::ffi::c_void,
6220 wkspSize: size_t,
6221 writeEntropy: core::ffi::c_int,
6222) -> size_t {
6223 let sequencesSectionHeaderSize =
6224 (1 + 1
6225 + (nbSeq >= 128) as core::ffi::c_int
6226 + (nbSeq >= LONGNBSEQ as size_t) as core::ffi::c_int) as size_t;
6227 let mut cSeqSizeEstimate = 0 as size_t;
6228 cSeqSizeEstimate = cSeqSizeEstimate.wrapping_add(ZSTD_estimateBlockSize_symbolType(
6229 (*fseMetadata).ofType,
6230 ofCodeTable,
6231 nbSeq,
6232 MaxOff as core::ffi::c_uint,
6233 ((*fseTables).offcodeCTable).as_ptr(),
6234 core::ptr::null(),
6235 OF_defaultNorm.as_ptr(),
6236 OF_defaultNormLog,
6237 DefaultMaxOff as u32,
6238 workspace,
6239 wkspSize,
6240 ));
6241 cSeqSizeEstimate = cSeqSizeEstimate.wrapping_add(ZSTD_estimateBlockSize_symbolType(
6242 (*fseMetadata).llType,
6243 llCodeTable,
6244 nbSeq,
6245 MaxLL as core::ffi::c_uint,
6246 ((*fseTables).litlengthCTable).as_ptr(),
6247 LL_bits.as_ptr(),
6248 LL_defaultNorm.as_ptr(),
6249 LL_defaultNormLog,
6250 MaxLL as u32,
6251 workspace,
6252 wkspSize,
6253 ));
6254 cSeqSizeEstimate = cSeqSizeEstimate.wrapping_add(ZSTD_estimateBlockSize_symbolType(
6255 (*fseMetadata).mlType,
6256 mlCodeTable,
6257 nbSeq,
6258 MaxML as core::ffi::c_uint,
6259 ((*fseTables).matchlengthCTable).as_ptr(),
6260 ML_bits.as_ptr(),
6261 ML_defaultNorm.as_ptr(),
6262 ML_defaultNormLog,
6263 MaxML as u32,
6264 workspace,
6265 wkspSize,
6266 ));
6267 if writeEntropy != 0 {
6268 cSeqSizeEstimate = cSeqSizeEstimate.wrapping_add((*fseMetadata).fseTablesSize);
6269 }
6270 cSeqSizeEstimate.wrapping_add(sequencesSectionHeaderSize)
6271}
6272unsafe fn ZSTD_estimateBlockSize(
6273 literals: *const u8,
6274 litSize: size_t,
6275 ofCodeTable: *const u8,
6276 llCodeTable: *const u8,
6277 mlCodeTable: *const u8,
6278 nbSeq: size_t,
6279 entropy: *const ZSTD_entropyCTables_t,
6280 entropyMetadata: *const ZSTD_entropyCTablesMetadata_t,
6281 workspace: *mut core::ffi::c_void,
6282 wkspSize: size_t,
6283 writeLitEntropy: core::ffi::c_int,
6284 writeSeqEntropy: core::ffi::c_int,
6285) -> size_t {
6286 let literalsSize = ZSTD_estimateBlockSize_literal(
6287 literals,
6288 litSize,
6289 &(*entropy).huf,
6290 &(*entropyMetadata).hufMetadata,
6291 workspace,
6292 wkspSize,
6293 writeLitEntropy,
6294 );
6295 let seqSize = ZSTD_estimateBlockSize_sequences(
6296 ofCodeTable,
6297 llCodeTable,
6298 mlCodeTable,
6299 nbSeq,
6300 &(*entropy).fse,
6301 &(*entropyMetadata).fseMetadata,
6302 workspace,
6303 wkspSize,
6304 writeSeqEntropy,
6305 );
6306 seqSize
6307 .wrapping_add(literalsSize)
6308 .wrapping_add(ZSTD_blockHeaderSize)
6309}
6310unsafe fn ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(
6311 seqStore: *mut SeqStore_t,
6312 zc: *mut ZSTD_CCtx,
6313) -> size_t {
6314 let entropyMetadata: *mut ZSTD_entropyCTablesMetadata_t =
6315 &mut (*zc).blockSplitCtx.entropyMetadata;
6316 let err_code = ZSTD_buildBlockEntropyStats(
6317 seqStore,
6318 &(*(*zc).blockState.prevCBlock).entropy,
6319 &mut (*(*zc).blockState.nextCBlock).entropy,
6320 &(*zc).appliedParams,
6321 entropyMetadata,
6322 (*zc).tmpWorkspace,
6323 (*zc).tmpWkspSize,
6324 );
6325 if ERR_isError(err_code) {
6326 return err_code;
6327 }
6328 ZSTD_estimateBlockSize(
6329 (*seqStore).litStart,
6330 ((*seqStore).lit).offset_from((*seqStore).litStart) as size_t,
6331 (*seqStore).ofCode,
6332 (*seqStore).llCode,
6333 (*seqStore).mlCode,
6334 ((*seqStore).sequences).offset_from((*seqStore).sequencesStart) as core::ffi::c_long
6335 as size_t,
6336 &(*(*zc).blockState.nextCBlock).entropy,
6337 entropyMetadata,
6338 (*zc).tmpWorkspace,
6339 (*zc).tmpWkspSize,
6340 ((*entropyMetadata).hufMetadata.hType as core::ffi::c_uint
6341 == set_compressed as core::ffi::c_int as core::ffi::c_uint) as core::ffi::c_int,
6342 1,
6343 )
6344}
6345unsafe fn ZSTD_countSeqStoreLiteralsBytes(seqStore: *const SeqStore_t) -> size_t {
6346 let mut literalsBytes = 0 as size_t;
6347 let nbSeqs = ((*seqStore).sequences).offset_from((*seqStore).sequencesStart) as size_t;
6348 let mut i: size_t = 0;
6349 i = 0;
6350 while i < nbSeqs {
6351 let seq = *((*seqStore).sequencesStart).add(i);
6352 literalsBytes = literalsBytes.wrapping_add(seq.litLength as size_t);
6353 if i == (*seqStore).longLengthPos as size_t
6354 && (*seqStore).longLengthType as core::ffi::c_uint
6355 == ZSTD_llt_literalLength as core::ffi::c_int as core::ffi::c_uint
6356 {
6357 literalsBytes = literalsBytes.wrapping_add(0x10000 as core::ffi::c_int as size_t);
6358 }
6359 i = i.wrapping_add(1);
6360 }
6361 literalsBytes
6362}
6363unsafe fn ZSTD_countSeqStoreMatchBytes(seqStore: *const SeqStore_t) -> size_t {
6364 let mut matchBytes = 0 as size_t;
6365 let nbSeqs = ((*seqStore).sequences).offset_from((*seqStore).sequencesStart) as size_t;
6366 let mut i: size_t = 0;
6367 i = 0;
6368 while i < nbSeqs {
6369 let seq = *((*seqStore).sequencesStart).add(i);
6370 matchBytes = matchBytes.wrapping_add((seq.mlBase as core::ffi::c_int + MINMATCH) as size_t);
6371 if i == (*seqStore).longLengthPos as size_t
6372 && (*seqStore).longLengthType as core::ffi::c_uint
6373 == ZSTD_llt_matchLength as core::ffi::c_int as core::ffi::c_uint
6374 {
6375 matchBytes = matchBytes.wrapping_add(0x10000 as core::ffi::c_int as size_t);
6376 }
6377 i = i.wrapping_add(1);
6378 }
6379 matchBytes
6380}
6381unsafe fn ZSTD_deriveSeqStoreChunk(
6382 resultSeqStore: *mut SeqStore_t,
6383 originalSeqStore: *const SeqStore_t,
6384 startIdx: size_t,
6385 endIdx: size_t,
6386) {
6387 *resultSeqStore = *originalSeqStore;
6388 if startIdx > 0 {
6389 (*resultSeqStore).sequences = ((*originalSeqStore).sequencesStart).add(startIdx);
6390 (*resultSeqStore).litStart =
6391 ((*resultSeqStore).litStart).add(ZSTD_countSeqStoreLiteralsBytes(resultSeqStore));
6392 }
6393 if (*originalSeqStore).longLengthType as core::ffi::c_uint
6394 != ZSTD_llt_none as core::ffi::c_int as core::ffi::c_uint
6395 {
6396 if ((*originalSeqStore).longLengthPos as size_t) < startIdx
6397 || (*originalSeqStore).longLengthPos as size_t > endIdx
6398 {
6399 (*resultSeqStore).longLengthType = ZSTD_llt_none;
6400 } else {
6401 (*resultSeqStore).longLengthPos =
6402 ((*resultSeqStore).longLengthPos).wrapping_sub(startIdx as u32);
6403 }
6404 }
6405 (*resultSeqStore).sequencesStart = ((*originalSeqStore).sequencesStart).add(startIdx);
6406 (*resultSeqStore).sequences = ((*originalSeqStore).sequencesStart).add(endIdx);
6407 if endIdx
6408 != ((*originalSeqStore).sequences).offset_from((*originalSeqStore).sequencesStart) as size_t
6409 {
6410 let literalsBytes = ZSTD_countSeqStoreLiteralsBytes(resultSeqStore);
6411 (*resultSeqStore).lit = ((*resultSeqStore).litStart).add(literalsBytes);
6412 }
6413 (*resultSeqStore).llCode = ((*resultSeqStore).llCode).add(startIdx);
6414 (*resultSeqStore).mlCode = ((*resultSeqStore).mlCode).add(startIdx);
6415 (*resultSeqStore).ofCode = ((*resultSeqStore).ofCode).add(startIdx);
6416}
6417unsafe fn ZSTD_resolveRepcodeToRawOffset(rep: *const u32, offBase: u32, ll0: u32) -> u32 {
6418 let adjustedRepCode = offBase.wrapping_sub(1).wrapping_add(ll0);
6419 if adjustedRepCode == ZSTD_REP_NUM as u32 {
6420 return (*rep.offset(0)).wrapping_sub(1);
6421 }
6422 *rep.offset(adjustedRepCode as isize)
6423}
6424unsafe fn ZSTD_seqStore_resolveOffCodes(
6425 dRepcodes: *mut Repcodes_t,
6426 cRepcodes: *mut Repcodes_t,
6427 seqStore: *const SeqStore_t,
6428 nbSeq: u32,
6429) {
6430 let mut idx = 0;
6431 let longLitLenIdx = if (*seqStore).longLengthType as core::ffi::c_uint
6432 == ZSTD_llt_literalLength as core::ffi::c_int as core::ffi::c_uint
6433 {
6434 (*seqStore).longLengthPos
6435 } else {
6436 nbSeq
6437 };
6438 while idx < nbSeq {
6439 let seq = ((*seqStore).sequencesStart).offset(idx as isize);
6440 let ll0 = ((*seq).litLength as core::ffi::c_int == 0 && idx != longLitLenIdx)
6441 as core::ffi::c_int as u32;
6442 let offBase = (*seq).offBase;
6443 if 1 <= offBase && offBase <= ZSTD_REP_NUM as u32 {
6444 let dRawOffset = ZSTD_resolveRepcodeToRawOffset(
6445 ((*dRepcodes).rep).as_mut_ptr() as *const u32,
6446 offBase,
6447 ll0,
6448 );
6449 let cRawOffset = ZSTD_resolveRepcodeToRawOffset(
6450 ((*cRepcodes).rep).as_mut_ptr() as *const u32,
6451 offBase,
6452 ll0,
6453 );
6454 if dRawOffset != cRawOffset {
6455 (*seq).offBase = cRawOffset.wrapping_add(ZSTD_REP_NUM as u32);
6456 }
6457 }
6458 ZSTD_updateRep(((*dRepcodes).rep).as_mut_ptr(), (*seq).offBase, ll0);
6459 ZSTD_updateRep(((*cRepcodes).rep).as_mut_ptr(), offBase, ll0);
6460 idx = idx.wrapping_add(1);
6461 }
6462}
6463unsafe fn ZSTD_compressSeqStore_singleBlock(
6464 zc: *mut ZSTD_CCtx,
6465 seqStore: *const SeqStore_t,
6466 dRep: *mut Repcodes_t,
6467 cRep: *mut Repcodes_t,
6468 dst: *mut core::ffi::c_void,
6469 dstCapacity: size_t,
6470 src: *const core::ffi::c_void,
6471 srcSize: size_t,
6472 lastBlock: u32,
6473 isPartition: u32,
6474) -> size_t {
6475 let rleMaxLength = 25;
6476 let op = dst as *mut u8;
6477 let ip = src as *const u8;
6478 let mut cSize: size_t = 0;
6479 let mut cSeqsSize: size_t = 0;
6480 let dRepOriginal = *dRep;
6481 if isPartition != 0 {
6482 ZSTD_seqStore_resolveOffCodes(
6483 dRep,
6484 cRep,
6485 seqStore,
6486 ((*seqStore).sequences).offset_from((*seqStore).sequencesStart) as core::ffi::c_long
6487 as u32,
6488 );
6489 }
6490 if dstCapacity < ZSTD_blockHeaderSize {
6491 return Error::dstSize_tooSmall.to_error_code();
6492 }
6493 cSeqsSize = ZSTD_entropyCompressSeqStore(
6494 seqStore,
6495 &(*(*zc).blockState.prevCBlock).entropy,
6496 &mut (*(*zc).blockState.nextCBlock).entropy,
6497 &(*zc).appliedParams,
6498 op.add(ZSTD_blockHeaderSize) as *mut core::ffi::c_void,
6499 dstCapacity.wrapping_sub(ZSTD_blockHeaderSize),
6500 srcSize,
6501 (*zc).tmpWorkspace,
6502 (*zc).tmpWkspSize,
6503 (*zc).bmi2,
6504 );
6505 let err_code = cSeqsSize;
6506 if ERR_isError(err_code) {
6507 return err_code;
6508 }
6509 if (*zc).isFirstBlock == 0
6510 && cSeqsSize < rleMaxLength as size_t
6511 && ZSTD_isRLE(src as *const u8, srcSize) != 0
6512 {
6513 cSeqsSize = 1;
6514 }
6515 if (*zc).seqCollector.collectSequences != 0 {
6516 let err_code_0 = ZSTD_copyBlockSequences(
6517 &mut (*zc).seqCollector,
6518 seqStore,
6519 (dRepOriginal.rep).as_ptr(),
6520 );
6521 if ERR_isError(err_code_0) {
6522 return err_code_0;
6523 }
6524 ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*zc).blockState);
6525 return 0;
6526 }
6527 if cSeqsSize == 0 {
6528 cSize = ZSTD_noCompressBlock(
6529 op as *mut core::ffi::c_void,
6530 dstCapacity,
6531 ip as *const core::ffi::c_void,
6532 srcSize,
6533 lastBlock,
6534 );
6535 let err_code_1 = cSize;
6536 if ERR_isError(err_code_1) {
6537 return err_code_1;
6538 }
6539 *dRep = dRepOriginal;
6540 } else if cSeqsSize == 1 {
6541 cSize = ZSTD_rleCompressBlock(
6542 op as *mut core::ffi::c_void,
6543 dstCapacity,
6544 *ip,
6545 srcSize,
6546 lastBlock,
6547 );
6548 let err_code_2 = cSize;
6549 if ERR_isError(err_code_2) {
6550 return err_code_2;
6551 }
6552 *dRep = dRepOriginal;
6553 } else {
6554 ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*zc).blockState);
6555 writeBlockHeader(op as *mut core::ffi::c_void, cSeqsSize, srcSize, lastBlock);
6556 cSize = ZSTD_blockHeaderSize.wrapping_add(cSeqsSize);
6557 }
6558 if (*(*zc).blockState.prevCBlock)
6559 .entropy
6560 .fse
6561 .offcode_repeatMode as core::ffi::c_uint
6562 == FSE_repeat_valid as core::ffi::c_int as core::ffi::c_uint
6563 {
6564 (*(*zc).blockState.prevCBlock)
6565 .entropy
6566 .fse
6567 .offcode_repeatMode = FSE_repeat_check;
6568 }
6569 cSize
6570}
6571pub const MIN_SEQUENCES_BLOCK_SPLITTING: core::ffi::c_int = 300;
6572unsafe fn ZSTD_deriveBlockSplitsHelper(
6573 splits: *mut seqStoreSplits,
6574 startIdx: size_t,
6575 endIdx: size_t,
6576 zc: *mut ZSTD_CCtx,
6577 origSeqStore: *const SeqStore_t,
6578) {
6579 let fullSeqStoreChunk: *mut SeqStore_t = &mut (*zc).blockSplitCtx.fullSeqStoreChunk;
6580 let firstHalfSeqStore: *mut SeqStore_t = &mut (*zc).blockSplitCtx.firstHalfSeqStore;
6581 let secondHalfSeqStore: *mut SeqStore_t = &mut (*zc).blockSplitCtx.secondHalfSeqStore;
6582 let mut estimatedOriginalSize: size_t = 0;
6583 let mut estimatedFirstHalfSize: size_t = 0;
6584 let mut estimatedSecondHalfSize: size_t = 0;
6585 let midIdx = startIdx.wrapping_add(endIdx) / 2;
6586 if endIdx.wrapping_sub(startIdx) < MIN_SEQUENCES_BLOCK_SPLITTING as size_t
6587 || (*splits).idx >= ZSTD_MAX_NB_BLOCK_SPLITS as size_t
6588 {
6589 return;
6590 }
6591 ZSTD_deriveSeqStoreChunk(fullSeqStoreChunk, origSeqStore, startIdx, endIdx);
6592 ZSTD_deriveSeqStoreChunk(firstHalfSeqStore, origSeqStore, startIdx, midIdx);
6593 ZSTD_deriveSeqStoreChunk(secondHalfSeqStore, origSeqStore, midIdx, endIdx);
6594 estimatedOriginalSize =
6595 ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(fullSeqStoreChunk, zc);
6596 estimatedFirstHalfSize =
6597 ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(firstHalfSeqStore, zc);
6598 estimatedSecondHalfSize =
6599 ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(secondHalfSeqStore, zc);
6600 if ERR_isError(estimatedOriginalSize)
6601 || ERR_isError(estimatedFirstHalfSize)
6602 || ERR_isError(estimatedSecondHalfSize)
6603 {
6604 return;
6605 }
6606 if estimatedFirstHalfSize.wrapping_add(estimatedSecondHalfSize) < estimatedOriginalSize {
6607 ZSTD_deriveBlockSplitsHelper(splits, startIdx, midIdx, zc, origSeqStore);
6608 *((*splits).splitLocations).add((*splits).idx) = midIdx as u32;
6609 (*splits).idx = ((*splits).idx).wrapping_add(1);
6610 (*splits).idx;
6611 ZSTD_deriveBlockSplitsHelper(splits, midIdx, endIdx, zc, origSeqStore);
6612 }
6613}
6614unsafe fn ZSTD_deriveBlockSplits(zc: *mut ZSTD_CCtx, partitions: *mut u32, nbSeq: u32) -> size_t {
6615 let mut splits = seqStoreSplits {
6616 splitLocations: core::ptr::null_mut::<u32>(),
6617 idx: 0,
6618 };
6619 splits.splitLocations = partitions;
6620 splits.idx = 0;
6621 if nbSeq <= 4 {
6622 return 0;
6623 }
6624 ZSTD_deriveBlockSplitsHelper(&mut splits, 0, nbSeq as size_t, zc, &(*zc).seqStore);
6625 *(splits.splitLocations).add(splits.idx) = nbSeq;
6626 splits.idx
6627}
6628unsafe fn ZSTD_compressBlock_splitBlock_internal(
6629 zc: *mut ZSTD_CCtx,
6630 dst: *mut core::ffi::c_void,
6631 mut dstCapacity: size_t,
6632 src: *const core::ffi::c_void,
6633 blockSize: size_t,
6634 lastBlock: u32,
6635 nbSeq: u32,
6636) -> size_t {
6637 let mut cSize = 0 as size_t;
6638 let mut ip = src as *const u8;
6639 let mut op = dst as *mut u8;
6640 let mut i = 0;
6641 let mut srcBytesTotal = 0 as size_t;
6642 let partitions = ((*zc).blockSplitCtx.partitions).as_mut_ptr();
6643 let nextSeqStore: *mut SeqStore_t = &mut (*zc).blockSplitCtx.nextSeqStore;
6644 let currSeqStore: *mut SeqStore_t = &mut (*zc).blockSplitCtx.currSeqStore;
6645 let numSplits = ZSTD_deriveBlockSplits(zc, partitions, nbSeq);
6646 let mut dRep = repcodes_s { rep: [0; 3] };
6647 let mut cRep = repcodes_s { rep: [0; 3] };
6648 libc::memcpy(
6649 (dRep.rep).as_mut_ptr() as *mut core::ffi::c_void,
6650 ((*(*zc).blockState.prevCBlock).rep).as_mut_ptr() as *const core::ffi::c_void,
6651 ::core::mem::size_of::<Repcodes_t>(),
6652 );
6653 libc::memcpy(
6654 (cRep.rep).as_mut_ptr() as *mut core::ffi::c_void,
6655 ((*(*zc).blockState.prevCBlock).rep).as_mut_ptr() as *const core::ffi::c_void,
6656 ::core::mem::size_of::<Repcodes_t>(),
6657 );
6658 ptr::write_bytes(
6659 nextSeqStore as *mut u8,
6660 0,
6661 ::core::mem::size_of::<SeqStore_t>(),
6662 );
6663 if numSplits == 0 {
6664 let cSizeSingleBlock = ZSTD_compressSeqStore_singleBlock(
6665 zc,
6666 &(*zc).seqStore,
6667 &mut dRep,
6668 &mut cRep,
6669 op as *mut core::ffi::c_void,
6670 dstCapacity,
6671 ip as *const core::ffi::c_void,
6672 blockSize,
6673 lastBlock,
6674 0,
6675 );
6676 let err_code = cSizeSingleBlock;
6677 if ERR_isError(err_code) {
6678 return err_code;
6679 }
6680 return cSizeSingleBlock;
6681 }
6682 ZSTD_deriveSeqStoreChunk(
6683 currSeqStore,
6684 &(*zc).seqStore,
6685 0,
6686 *partitions.offset(0) as size_t,
6687 );
6688 i = 0;
6689 while i <= numSplits {
6690 let mut cSizeChunk: size_t = 0;
6691 let lastPartition = (i == numSplits) as core::ffi::c_int as u32;
6692 let mut lastBlockEntireSrc = 0;
6693 let mut srcBytes = (ZSTD_countSeqStoreLiteralsBytes(currSeqStore))
6694 .wrapping_add(ZSTD_countSeqStoreMatchBytes(currSeqStore));
6695 srcBytesTotal = srcBytesTotal.wrapping_add(srcBytes);
6696 if lastPartition != 0 {
6697 srcBytes = srcBytes.wrapping_add(blockSize.wrapping_sub(srcBytesTotal));
6698 lastBlockEntireSrc = lastBlock;
6699 } else {
6700 ZSTD_deriveSeqStoreChunk(
6701 nextSeqStore,
6702 &(*zc).seqStore,
6703 *partitions.add(i) as size_t,
6704 *partitions.add(i.wrapping_add(1)) as size_t,
6705 );
6706 }
6707 cSizeChunk = ZSTD_compressSeqStore_singleBlock(
6708 zc,
6709 currSeqStore,
6710 &mut dRep,
6711 &mut cRep,
6712 op as *mut core::ffi::c_void,
6713 dstCapacity,
6714 ip as *const core::ffi::c_void,
6715 srcBytes,
6716 lastBlockEntireSrc,
6717 1,
6718 );
6719 let err_code_0 = cSizeChunk;
6720 if ERR_isError(err_code_0) {
6721 return err_code_0;
6722 }
6723 ip = ip.add(srcBytes);
6724 op = op.add(cSizeChunk);
6725 dstCapacity = dstCapacity.wrapping_sub(cSizeChunk);
6726 cSize = cSize.wrapping_add(cSizeChunk);
6727 *currSeqStore = *nextSeqStore;
6728 i = i.wrapping_add(1);
6729 }
6730 libc::memcpy(
6731 ((*(*zc).blockState.prevCBlock).rep).as_mut_ptr() as *mut core::ffi::c_void,
6732 (dRep.rep).as_mut_ptr() as *const core::ffi::c_void,
6733 ::core::mem::size_of::<Repcodes_t>(),
6734 );
6735 cSize
6736}
6737unsafe fn ZSTD_compressBlock_splitBlock(
6738 zc: *mut ZSTD_CCtx,
6739 dst: *mut core::ffi::c_void,
6740 dstCapacity: size_t,
6741 src: *const core::ffi::c_void,
6742 srcSize: size_t,
6743 lastBlock: u32,
6744) -> size_t {
6745 let mut nbSeq: u32 = 0;
6746 let mut cSize: size_t = 0;
6747 let bss = ZSTD_buildSeqStore(zc, src, srcSize);
6748 let err_code = bss;
6749 if ERR_isError(err_code) {
6750 return err_code;
6751 }
6752 if bss == ZSTDbss_noCompress as core::ffi::c_int as size_t {
6753 if (*(*zc).blockState.prevCBlock)
6754 .entropy
6755 .fse
6756 .offcode_repeatMode as core::ffi::c_uint
6757 == FSE_repeat_valid as core::ffi::c_int as core::ffi::c_uint
6758 {
6759 (*(*zc).blockState.prevCBlock)
6760 .entropy
6761 .fse
6762 .offcode_repeatMode = FSE_repeat_check;
6763 }
6764 if (*zc).seqCollector.collectSequences != 0 {
6765 return Error::sequenceProducer_failed.to_error_code();
6766 }
6767 cSize = ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);
6768 let err_code_0 = cSize;
6769 if ERR_isError(err_code_0) {
6770 return err_code_0;
6771 }
6772 return cSize;
6773 }
6774 nbSeq = ((*zc).seqStore.sequences).offset_from((*zc).seqStore.sequencesStart)
6775 as core::ffi::c_long as u32;
6776 cSize = ZSTD_compressBlock_splitBlock_internal(
6777 zc,
6778 dst,
6779 dstCapacity,
6780 src,
6781 srcSize,
6782 lastBlock,
6783 nbSeq,
6784 );
6785 let err_code_1 = cSize;
6786 if ERR_isError(err_code_1) {
6787 return err_code_1;
6788 }
6789 cSize
6790}
6791unsafe fn ZSTD_compressBlock_internal(
6792 zc: *mut ZSTD_CCtx,
6793 dst: *mut core::ffi::c_void,
6794 dstCapacity: size_t,
6795 src: *const core::ffi::c_void,
6796 srcSize: size_t,
6797 frame: u32,
6798) -> size_t {
6799 let rleMaxLength = 25;
6800 let mut cSize: size_t = 0;
6801 let ip = src as *const u8;
6802 let op = dst as *mut u8;
6803 let bss = ZSTD_buildSeqStore(zc, src, srcSize);
6804 let err_code = bss;
6805 if ERR_isError(err_code) {
6806 return err_code;
6807 }
6808 if bss == ZSTDbss_noCompress as core::ffi::c_int as size_t {
6809 if (*zc).seqCollector.collectSequences != 0 {
6810 return Error::sequenceProducer_failed.to_error_code();
6811 }
6812 cSize = 0;
6813 } else {
6814 if (*zc).seqCollector.collectSequences != 0 {
6815 let err_code_0 = ZSTD_copyBlockSequences(
6816 &mut (*zc).seqCollector,
6817 ZSTD_getSeqStore(zc),
6818 ((*(*zc).blockState.prevCBlock).rep).as_mut_ptr() as *const u32,
6819 );
6820 if ERR_isError(err_code_0) {
6821 return err_code_0;
6822 }
6823 ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*zc).blockState);
6824 return 0;
6825 }
6826 cSize = ZSTD_entropyCompressSeqStore(
6827 &(*zc).seqStore,
6828 &(*(*zc).blockState.prevCBlock).entropy,
6829 &mut (*(*zc).blockState.nextCBlock).entropy,
6830 &(*zc).appliedParams,
6831 dst,
6832 dstCapacity,
6833 srcSize,
6834 (*zc).tmpWorkspace,
6835 (*zc).tmpWkspSize,
6836 (*zc).bmi2,
6837 );
6838 if frame != 0
6839 && (*zc).isFirstBlock == 0
6840 && cSize < rleMaxLength as size_t
6841 && ZSTD_isRLE(ip, srcSize) != 0
6842 {
6843 cSize = 1;
6844 *op.offset(0) = *ip.offset(0);
6845 }
6846 }
6847 if !ERR_isError(cSize) && cSize > 1 {
6848 ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*zc).blockState);
6849 }
6850 if (*(*zc).blockState.prevCBlock)
6851 .entropy
6852 .fse
6853 .offcode_repeatMode as core::ffi::c_uint
6854 == FSE_repeat_valid as core::ffi::c_int as core::ffi::c_uint
6855 {
6856 (*(*zc).blockState.prevCBlock)
6857 .entropy
6858 .fse
6859 .offcode_repeatMode = FSE_repeat_check;
6860 }
6861 cSize
6862}
6863unsafe fn ZSTD_compressBlock_targetCBlockSize_body(
6864 zc: *mut ZSTD_CCtx,
6865 dst: *mut core::ffi::c_void,
6866 dstCapacity: size_t,
6867 src: *const core::ffi::c_void,
6868 srcSize: size_t,
6869 bss: size_t,
6870 lastBlock: u32,
6871) -> size_t {
6872 if bss == ZSTDbss_compress as core::ffi::c_int as size_t {
6873 if (*zc).isFirstBlock == 0
6874 && ZSTD_maybeRLE(&(*zc).seqStore) != 0
6875 && ZSTD_isRLE(src as *const u8, srcSize) != 0
6876 {
6877 return ZSTD_rleCompressBlock(
6878 dst,
6879 dstCapacity,
6880 *(src as *const u8),
6881 srcSize,
6882 lastBlock,
6883 );
6884 }
6885 let cSize = ZSTD_compressSuperBlock(zc, dst, dstCapacity, src, srcSize, lastBlock);
6886 if cSize != Error::dstSize_tooSmall.to_error_code() {
6887 let maxCSize =
6888 srcSize.wrapping_sub(ZSTD_minGain(srcSize, (*zc).appliedParams.cParams.strategy));
6889 let err_code = cSize;
6890 if ERR_isError(err_code) {
6891 return err_code;
6892 }
6893 if cSize != 0 && cSize < maxCSize.wrapping_add(ZSTD_blockHeaderSize) {
6894 ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*zc).blockState);
6895 return cSize;
6896 }
6897 }
6898 }
6899 ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock)
6900}
6901unsafe fn ZSTD_compressBlock_targetCBlockSize(
6902 zc: *mut ZSTD_CCtx,
6903 dst: *mut core::ffi::c_void,
6904 dstCapacity: size_t,
6905 src: *const core::ffi::c_void,
6906 srcSize: size_t,
6907 lastBlock: u32,
6908) -> size_t {
6909 let mut cSize = 0;
6910 let bss = ZSTD_buildSeqStore(zc, src, srcSize);
6911 let err_code = bss;
6912 if ERR_isError(err_code) {
6913 return err_code;
6914 }
6915 cSize = ZSTD_compressBlock_targetCBlockSize_body(
6916 zc,
6917 dst,
6918 dstCapacity,
6919 src,
6920 srcSize,
6921 bss,
6922 lastBlock,
6923 );
6924 let err_code_0 = cSize;
6925 if ERR_isError(err_code_0) {
6926 return err_code_0;
6927 }
6928 if (*(*zc).blockState.prevCBlock)
6929 .entropy
6930 .fse
6931 .offcode_repeatMode as core::ffi::c_uint
6932 == FSE_repeat_valid as core::ffi::c_int as core::ffi::c_uint
6933 {
6934 (*(*zc).blockState.prevCBlock)
6935 .entropy
6936 .fse
6937 .offcode_repeatMode = FSE_repeat_check;
6938 }
6939 cSize
6940}
6941unsafe fn ZSTD_overflowCorrectIfNeeded(
6942 ms: *mut ZSTD_MatchState_t,
6943 ws: *mut ZSTD_cwksp,
6944 params: *const ZSTD_CCtx_params,
6945 ip: *const core::ffi::c_void,
6946 iend: *const core::ffi::c_void,
6947) {
6948 let cycleLog = ZSTD_cycleLog((*params).cParams.chainLog, (*params).cParams.strategy);
6949 let maxDist = (1) << (*params).cParams.windowLog;
6950 if ZSTD_window_needOverflowCorrection(
6951 (*ms).window,
6952 cycleLog,
6953 maxDist,
6954 (*ms).loadedDictEnd,
6955 ip,
6956 iend,
6957 ) != 0
6958 {
6959 let correction = ZSTD_window_correctOverflow(&mut (*ms).window, cycleLog, maxDist, ip);
6960 ZSTD_cwksp_mark_tables_dirty(ws);
6961 ZSTD_reduceIndex(ms, params, correction);
6962 ZSTD_cwksp_mark_tables_clean(ws);
6963 if (*ms).nextToUpdate < correction {
6964 (*ms).nextToUpdate = 0;
6965 } else {
6966 (*ms).nextToUpdate = ((*ms).nextToUpdate).wrapping_sub(correction);
6967 }
6968 (*ms).loadedDictEnd = 0;
6969 (*ms).dictMatchState = core::ptr::null();
6970 }
6971}
6972unsafe fn ZSTD_optimalBlockSize(
6973 cctx: *mut ZSTD_CCtx,
6974 src: *const core::ffi::c_void,
6975 srcSize: size_t,
6976 blockSizeMax: size_t,
6977 mut splitLevel: core::ffi::c_int,
6978 strat: ZSTD_strategy,
6979 savings: S64,
6980) -> size_t {
6981 static splitLevels: [core::ffi::c_int; 10] = [0, 0, 1, 2, 2, 3, 3, 4, 4, 4];
6982 if srcSize < (128 * ((1) << 10)) as size_t || blockSizeMax < (128 * ((1) << 10)) as size_t {
6983 return if srcSize < blockSizeMax {
6984 srcSize
6985 } else {
6986 blockSizeMax
6987 };
6988 }
6989 if savings < 3 {
6990 return (128 * ((1) << 10)) as size_t;
6991 }
6992 if splitLevel == 1 {
6993 return (128 * ((1) << 10)) as size_t;
6994 }
6995 if splitLevel == 0 {
6996 splitLevel = *splitLevels.as_ptr().offset(strat as isize);
6997 } else {
6998 splitLevel -= 2;
6999 }
7000 ZSTD_splitBlock(
7001 src,
7002 blockSizeMax,
7003 splitLevel,
7004 (*cctx).tmpWorkspace,
7005 (*cctx).tmpWkspSize,
7006 )
7007}
7008unsafe fn ZSTD_compress_frameChunk(
7009 cctx: *mut ZSTD_CCtx,
7010 dst: *mut core::ffi::c_void,
7011 mut dstCapacity: size_t,
7012 src: *const core::ffi::c_void,
7013 srcSize: size_t,
7014 lastFrameChunk: u32,
7015) -> size_t {
7016 let blockSizeMax = (*cctx).blockSizeMax;
7017 let mut remaining = srcSize;
7018 let mut ip = src as *const u8;
7019 let ostart = dst as *mut u8;
7020 let mut op = ostart;
7021 let maxDist = (1) << (*cctx).appliedParams.cParams.windowLog;
7022 let mut savings = (*cctx).consumedSrcSize as S64 - (*cctx).producedCSize as S64;
7023 if (*cctx).appliedParams.fParams.checksumFlag != 0 && srcSize != 0 {
7024 ZSTD_XXH64_update(&mut (*cctx).xxhState, src, srcSize);
7025 }
7026 while remaining != 0 {
7027 let ms: *mut ZSTD_MatchState_t = &mut (*cctx).blockState.matchState;
7028 let blockSize = ZSTD_optimalBlockSize(
7029 cctx,
7030 ip as *const core::ffi::c_void,
7031 remaining,
7032 blockSizeMax,
7033 (*cctx).appliedParams.preBlockSplitter_level,
7034 (*cctx).appliedParams.cParams.strategy,
7035 savings,
7036 );
7037 let lastBlock = lastFrameChunk & (blockSize == remaining) as core::ffi::c_int as u32;
7038 if dstCapacity
7039 < ZSTD_blockHeaderSize
7040 .wrapping_add((1 + 1) as size_t)
7041 .wrapping_add(1)
7042 {
7043 return Error::dstSize_tooSmall.to_error_code();
7044 }
7045 ZSTD_overflowCorrectIfNeeded(
7046 ms,
7047 &mut (*cctx).workspace,
7048 &(*cctx).appliedParams,
7049 ip as *const core::ffi::c_void,
7050 ip.add(blockSize) as *const core::ffi::c_void,
7051 );
7052 ZSTD_checkDictValidity(
7053 &(*ms).window,
7054 ip.add(blockSize) as *const core::ffi::c_void,
7055 maxDist,
7056 &mut (*ms).loadedDictEnd,
7057 &mut (*ms).dictMatchState,
7058 );
7059 ZSTD_window_enforceMaxDist(
7060 &mut (*ms).window,
7061 ip as *const core::ffi::c_void,
7062 maxDist,
7063 &mut (*ms).loadedDictEnd,
7064 &mut (*ms).dictMatchState,
7065 );
7066 if (*ms).nextToUpdate < (*ms).window.lowLimit {
7067 (*ms).nextToUpdate = (*ms).window.lowLimit;
7068 }
7069 let mut cSize: size_t = 0;
7070 if ZSTD_useTargetCBlockSize(&(*cctx).appliedParams) != 0 {
7071 cSize = ZSTD_compressBlock_targetCBlockSize(
7072 cctx,
7073 op as *mut core::ffi::c_void,
7074 dstCapacity,
7075 ip as *const core::ffi::c_void,
7076 blockSize,
7077 lastBlock,
7078 );
7079 let err_code = cSize;
7080 if ERR_isError(err_code) {
7081 return err_code;
7082 }
7083 } else if ZSTD_blockSplitterEnabled(&mut (*cctx).appliedParams) != 0 {
7084 cSize = ZSTD_compressBlock_splitBlock(
7085 cctx,
7086 op as *mut core::ffi::c_void,
7087 dstCapacity,
7088 ip as *const core::ffi::c_void,
7089 blockSize,
7090 lastBlock,
7091 );
7092 let err_code_0 = cSize;
7093 if ERR_isError(err_code_0) {
7094 return err_code_0;
7095 }
7096 } else {
7097 cSize = ZSTD_compressBlock_internal(
7098 cctx,
7099 op.add(ZSTD_blockHeaderSize) as *mut core::ffi::c_void,
7100 dstCapacity.wrapping_sub(ZSTD_blockHeaderSize),
7101 ip as *const core::ffi::c_void,
7102 blockSize,
7103 1,
7104 );
7105 let err_code_1 = cSize;
7106 if ERR_isError(err_code_1) {
7107 return err_code_1;
7108 }
7109 if cSize == 0 {
7110 cSize = ZSTD_noCompressBlock(
7111 op as *mut core::ffi::c_void,
7112 dstCapacity,
7113 ip as *const core::ffi::c_void,
7114 blockSize,
7115 lastBlock,
7116 );
7117 let err_code_2 = cSize;
7118 if ERR_isError(err_code_2) {
7119 return err_code_2;
7120 }
7121 } else {
7122 let cBlockHeader = if cSize == 1 {
7123 lastBlock
7124 .wrapping_add((bt_rle as core::ffi::c_int as u32) << 1)
7125 .wrapping_add((blockSize << 3) as u32)
7126 } else {
7127 lastBlock
7128 .wrapping_add((bt_compressed as core::ffi::c_int as u32) << 1)
7129 .wrapping_add((cSize << 3) as u32)
7130 };
7131 MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader);
7132 cSize = cSize.wrapping_add(ZSTD_blockHeaderSize);
7133 }
7134 }
7135 savings += blockSize as S64 - cSize as S64;
7136 ip = ip.add(blockSize);
7137 remaining = remaining.wrapping_sub(blockSize);
7138 op = op.add(cSize);
7139 dstCapacity = dstCapacity.wrapping_sub(cSize);
7140 (*cctx).isFirstBlock = 0;
7141 }
7142 if lastFrameChunk != 0 && op > ostart {
7143 (*cctx).stage = ZSTDcs_ending;
7144 }
7145 op.offset_from(ostart) as size_t
7146}
7147unsafe fn ZSTD_writeFrameHeader(
7148 dst: *mut core::ffi::c_void,
7149 dstCapacity: size_t,
7150 params: *const ZSTD_CCtx_params,
7151 pledgedSrcSize: u64,
7152 dictID: u32,
7153) -> size_t {
7154 let op = dst as *mut u8;
7155 let dictIDSizeCodeLength = ((dictID > 0) as core::ffi::c_int
7156 + (dictID >= 256) as core::ffi::c_int
7157 + (dictID >= 65536) as core::ffi::c_int) as u32;
7158 let dictIDSizeCode = if (*params).fParams.noDictIDFlag != 0 {
7159 0
7160 } else {
7161 dictIDSizeCodeLength
7162 };
7163 let checksumFlag = ((*params).fParams.checksumFlag > 0) as core::ffi::c_int as u32;
7164 let windowSize = (1) << (*params).cParams.windowLog;
7165 let singleSegment = ((*params).fParams.contentSizeFlag != 0
7166 && windowSize as u64 >= pledgedSrcSize) as core::ffi::c_int as u32;
7167 let windowLogByte = (((*params).cParams.windowLog)
7168 .wrapping_sub(ZSTD_WINDOWLOG_ABSOLUTEMIN as core::ffi::c_uint)
7169 << 3) as u8;
7170 let fcsCode = (if (*params).fParams.contentSizeFlag != 0 {
7171 (pledgedSrcSize >= 256) as core::ffi::c_int
7172 + (pledgedSrcSize >= (65536 + 256) as u64) as core::ffi::c_int
7173 + (pledgedSrcSize >= 0xffffffff as core::ffi::c_uint as u64) as core::ffi::c_int
7174 } else {
7175 0
7176 }) as u32;
7177 let frameHeaderDescriptionByte = dictIDSizeCode
7178 .wrapping_add(checksumFlag << 2)
7179 .wrapping_add(singleSegment << 5)
7180 .wrapping_add(fcsCode << 6) as u8;
7181 let mut pos = 0 as size_t;
7182 if dstCapacity < 18 {
7183 return Error::dstSize_tooSmall.to_error_code();
7184 }
7185 if (*params).format == Format::ZSTD_f_zstd1 {
7186 MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
7187 pos = 4;
7188 }
7189 let fresh7 = pos;
7190 pos = pos.wrapping_add(1);
7191 *op.add(fresh7) = frameHeaderDescriptionByte;
7192 if singleSegment == 0 {
7193 let fresh8 = pos;
7194 pos = pos.wrapping_add(1);
7195 *op.add(fresh8) = windowLogByte;
7196 }
7197 match dictIDSizeCode {
7198 1 => {
7199 *op.add(pos) = dictID as u8;
7200 pos = pos.wrapping_add(1);
7201 }
7202 2 => {
7203 MEM_writeLE16(op.add(pos) as *mut core::ffi::c_void, dictID as u16);
7204 pos = pos.wrapping_add(2);
7205 }
7206 3 => {
7207 MEM_writeLE32(op.add(pos) as *mut core::ffi::c_void, dictID);
7208 pos = pos.wrapping_add(4);
7209 }
7210 0 | _ => {}
7211 }
7212 match fcsCode {
7213 1 => {
7214 MEM_writeLE16(
7215 op.add(pos) as *mut core::ffi::c_void,
7216 pledgedSrcSize.wrapping_sub(256) as u16,
7217 );
7218 pos = pos.wrapping_add(2);
7219 }
7220 2 => {
7221 MEM_writeLE32(op.add(pos) as *mut core::ffi::c_void, pledgedSrcSize as u32);
7222 pos = pos.wrapping_add(4);
7223 }
7224 3 => {
7225 MEM_writeLE64(op.add(pos) as *mut core::ffi::c_void, pledgedSrcSize);
7226 pos = pos.wrapping_add(8);
7227 }
7228 0 | _ => {
7229 if singleSegment != 0 {
7230 let fresh9 = pos;
7231 pos = pos.wrapping_add(1);
7232 *op.add(fresh9) = pledgedSrcSize as u8;
7233 }
7234 }
7235 }
7236 pos
7237}
7238#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_writeSkippableFrame))]
7239pub unsafe extern "C" fn ZSTD_writeSkippableFrame(
7240 dst: *mut core::ffi::c_void,
7241 dstCapacity: size_t,
7242 src: *const core::ffi::c_void,
7243 srcSize: size_t,
7244 magicVariant: core::ffi::c_uint,
7245) -> size_t {
7246 let op = dst as *mut u8;
7247 if dstCapacity < srcSize.wrapping_add(8) {
7248 return Error::dstSize_tooSmall.to_error_code();
7249 }
7250 if srcSize > 0xffffffff as core::ffi::c_uint as size_t {
7251 return Error::srcSize_wrong.to_error_code();
7252 }
7253 if magicVariant > 15 {
7254 return Error::parameter_outOfBound.to_error_code();
7255 }
7256 MEM_writeLE32(
7257 op as *mut core::ffi::c_void,
7258 (ZSTD_MAGIC_SKIPPABLE_START as core::ffi::c_uint).wrapping_add(magicVariant),
7259 );
7260 MEM_writeLE32(op.offset(4) as *mut core::ffi::c_void, srcSize as u32);
7261 libc::memcpy(
7262 op.offset(8) as *mut core::ffi::c_void,
7263 src,
7264 srcSize as libc::size_t,
7265 );
7266 srcSize.wrapping_add(ZSTD_SKIPPABLEHEADERSIZE as size_t)
7267}
7268pub unsafe fn ZSTD_writeLastEmptyBlock(dst: *mut core::ffi::c_void, dstCapacity: size_t) -> size_t {
7269 if dstCapacity < ZSTD_blockHeaderSize {
7270 return Error::dstSize_tooSmall.to_error_code();
7271 }
7272 let cBlockHeader24 = (1u32).wrapping_add((bt_raw as core::ffi::c_int as u32) << 1);
7273 MEM_writeLE24(dst, cBlockHeader24);
7274 ZSTD_blockHeaderSize
7275}
7276pub unsafe fn ZSTD_referenceExternalSequences(
7277 cctx: *mut ZSTD_CCtx,
7278 seq: *mut rawSeq,
7279 nbSeq: size_t,
7280) {
7281 (*cctx).externSeqStore.seq = seq;
7282 (*cctx).externSeqStore.size = nbSeq;
7283 (*cctx).externSeqStore.capacity = nbSeq;
7284 (*cctx).externSeqStore.pos = 0;
7285 (*cctx).externSeqStore.posInSequence = 0;
7286}
7287unsafe extern "C" fn ZSTD_compressContinue_internal(
7288 cctx: *mut ZSTD_CCtx,
7289 mut dst: *mut core::ffi::c_void,
7290 mut dstCapacity: size_t,
7291 src: *const core::ffi::c_void,
7292 srcSize: size_t,
7293 frame: u32,
7294 lastFrameChunk: u32,
7295) -> size_t {
7296 let ms: *mut ZSTD_MatchState_t = &mut (*cctx).blockState.matchState;
7297 let mut fhSize = 0;
7298 if (*cctx).stage as core::ffi::c_uint == ZSTDcs_created as core::ffi::c_int as core::ffi::c_uint
7299 {
7300 return Error::stage_wrong.to_error_code();
7301 }
7302 if frame != 0
7303 && (*cctx).stage as core::ffi::c_uint
7304 == ZSTDcs_init as core::ffi::c_int as core::ffi::c_uint
7305 {
7306 fhSize = ZSTD_writeFrameHeader(
7307 dst,
7308 dstCapacity,
7309 &(*cctx).appliedParams,
7310 ((*cctx).pledgedSrcSizePlusOne).wrapping_sub(1),
7311 (*cctx).dictID,
7312 );
7313 let err_code = fhSize;
7314 if ERR_isError(err_code) {
7315 return err_code;
7316 }
7317 dstCapacity = dstCapacity.wrapping_sub(fhSize);
7318 dst = (dst as *mut core::ffi::c_char).add(fhSize) as *mut core::ffi::c_void;
7319 (*cctx).stage = ZSTDcs_ongoing;
7320 }
7321 if srcSize == 0 {
7322 return fhSize;
7323 }
7324 if ZSTD_window_update(&mut (*ms).window, src, srcSize, (*ms).forceNonContiguous) == 0 {
7325 (*ms).forceNonContiguous = 0;
7326 (*ms).nextToUpdate = (*ms).window.dictLimit;
7327 }
7328 if (*cctx).appliedParams.ldmParams.enableLdm as core::ffi::c_uint
7329 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
7330 {
7331 ZSTD_window_update(&mut (*cctx).ldmState.window, src, srcSize, 0);
7332 }
7333 if frame == 0 {
7334 ZSTD_overflowCorrectIfNeeded(
7335 ms,
7336 &mut (*cctx).workspace,
7337 &(*cctx).appliedParams,
7338 src,
7339 (src as *const u8).add(srcSize) as *const core::ffi::c_void,
7340 );
7341 }
7342 let cSize = if frame != 0 {
7343 ZSTD_compress_frameChunk(cctx, dst, dstCapacity, src, srcSize, lastFrameChunk)
7344 } else {
7345 ZSTD_compressBlock_internal(cctx, dst, dstCapacity, src, srcSize, 0)
7346 };
7347 let err_code_0 = cSize;
7348 if ERR_isError(err_code_0) {
7349 return err_code_0;
7350 }
7351 (*cctx).consumedSrcSize =
7352 ((*cctx).consumedSrcSize).wrapping_add(srcSize as core::ffi::c_ulonglong);
7353 (*cctx).producedCSize =
7354 ((*cctx).producedCSize).wrapping_add(cSize.wrapping_add(fhSize) as core::ffi::c_ulonglong);
7355 if (*cctx).pledgedSrcSizePlusOne != 0
7356 && ((*cctx).consumedSrcSize).wrapping_add(1) > (*cctx).pledgedSrcSizePlusOne
7357 {
7358 return Error::srcSize_wrong.to_error_code();
7359 }
7360 cSize.wrapping_add(fhSize)
7361}
7362#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressContinue_public))]
7363pub unsafe extern "C" fn ZSTD_compressContinue_public(
7364 cctx: *mut ZSTD_CCtx,
7365 dst: *mut core::ffi::c_void,
7366 dstCapacity: size_t,
7367 src: *const core::ffi::c_void,
7368 srcSize: size_t,
7369) -> size_t {
7370 ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1, 0)
7371}
7372#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressContinue))]
7373pub unsafe extern "C" fn ZSTD_compressContinue(
7374 cctx: *mut ZSTD_CCtx,
7375 dst: *mut core::ffi::c_void,
7376 dstCapacity: size_t,
7377 src: *const core::ffi::c_void,
7378 srcSize: size_t,
7379) -> size_t {
7380 ZSTD_compressContinue_public(cctx, dst, dstCapacity, src, srcSize)
7381}
7382unsafe fn ZSTD_getBlockSize_deprecated(cctx: *const ZSTD_CCtx) -> size_t {
7383 let cParams = (*cctx).appliedParams.cParams;
7384 if (*cctx).appliedParams.maxBlockSize < (1) << cParams.windowLog {
7385 (*cctx).appliedParams.maxBlockSize
7386 } else {
7387 (1) << cParams.windowLog
7388 }
7389}
7390#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_getBlockSize))]
7391pub unsafe extern "C" fn ZSTD_getBlockSize(cctx: *const ZSTD_CCtx) -> size_t {
7392 ZSTD_getBlockSize_deprecated(cctx)
7393}
7394#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBlock_deprecated))]
7395pub unsafe extern "C" fn ZSTD_compressBlock_deprecated(
7396 cctx: *mut ZSTD_CCtx,
7397 dst: *mut core::ffi::c_void,
7398 dstCapacity: size_t,
7399 src: *const core::ffi::c_void,
7400 srcSize: size_t,
7401) -> size_t {
7402 let blockSizeMax = ZSTD_getBlockSize_deprecated(cctx);
7403 if srcSize > blockSizeMax {
7404 return Error::srcSize_wrong.to_error_code();
7405 }
7406 ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0, 0)
7407}
7408#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBlock))]
7409pub unsafe extern "C" fn ZSTD_compressBlock(
7410 cctx: *mut ZSTD_CCtx,
7411 dst: *mut core::ffi::c_void,
7412 dstCapacity: size_t,
7413 src: *const core::ffi::c_void,
7414 srcSize: size_t,
7415) -> size_t {
7416 ZSTD_compressBlock_deprecated(cctx, dst, dstCapacity, src, srcSize)
7417}
7418unsafe fn ZSTD_loadDictionaryContent(
7419 ms: *mut ZSTD_MatchState_t,
7420 ls: *mut ldmState_t,
7421 ws: *mut ZSTD_cwksp,
7422 params: *const ZSTD_CCtx_params,
7423 mut src: *const core::ffi::c_void,
7424 mut srcSize: size_t,
7425 dtlm: ZSTD_dictTableLoadMethod_e,
7426 tfp: ZSTD_tableFillPurpose_e,
7427) -> size_t {
7428 let mut ip = src as *const u8;
7429 let iend = ip.add(srcSize);
7430 let loadLdmDict = ((*params).ldmParams.enableLdm as core::ffi::c_uint
7431 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
7432 && !ls.is_null()) as core::ffi::c_int;
7433 ZSTD_assertEqualCParams((*params).cParams, (*ms).cParams);
7434 let mut maxDictSize = (if MEM_64bits() != 0 {
7435 (3500 as core::ffi::c_uint)
7436 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
7437 } else {
7438 (2000 as core::ffi::c_uint)
7439 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
7440 })
7441 .wrapping_sub(ZSTD_WINDOW_START_INDEX as core::ffi::c_uint);
7442 let CDictTaggedIndices = ZSTD_CDictIndicesAreTagged(&(*params).cParams);
7443 if CDictTaggedIndices != 0
7444 && tfp as core::ffi::c_uint == ZSTD_tfp_forCDict as core::ffi::c_int as core::ffi::c_uint
7445 {
7446 let shortCacheMaxDictSize = ((1 as core::ffi::c_uint) << (32 - ZSTD_SHORT_CACHE_TAG_BITS))
7447 .wrapping_sub(ZSTD_WINDOW_START_INDEX as core::ffi::c_uint);
7448 maxDictSize = if maxDictSize < shortCacheMaxDictSize {
7449 maxDictSize
7450 } else {
7451 shortCacheMaxDictSize
7452 };
7453 }
7454 if srcSize > maxDictSize as size_t {
7455 ip = iend.offset(-(maxDictSize as isize));
7456 src = ip as *const core::ffi::c_void;
7457 srcSize = maxDictSize as size_t;
7458 }
7459 if srcSize
7460 > (-(1 as core::ffi::c_int) as u32).wrapping_sub(if MEM_64bits() != 0 {
7461 (3500 as core::ffi::c_uint)
7462 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
7463 } else {
7464 (2000 as core::ffi::c_uint)
7465 .wrapping_mul(((1 as core::ffi::c_int) << 20) as core::ffi::c_uint)
7466 }) as size_t
7467 {
7468 loadLdmDict != 0;
7469 }
7470 ZSTD_window_update(&mut (*ms).window, src, srcSize, 0);
7471 if loadLdmDict != 0 {
7472 ZSTD_window_update(&mut (*ls).window, src, srcSize, 0);
7473 (*ls).loadedDictEnd = if (*params).forceWindow != 0 {
7474 0
7475 } else {
7476 iend.offset_from((*ls).window.base) as core::ffi::c_long as u32
7477 };
7478 ZSTD_ldm_fillHashTable(ls, ip, iend, &(*params).ldmParams);
7479 }
7480 let maxDictSize_0 = (1)
7481 << (if (if ((*params).cParams.hashLog).wrapping_add(3)
7482 > ((*params).cParams.chainLog).wrapping_add(1)
7483 {
7484 ((*params).cParams.hashLog).wrapping_add(3)
7485 } else {
7486 ((*params).cParams.chainLog).wrapping_add(1)
7487 }) < 31
7488 {
7489 if ((*params).cParams.hashLog).wrapping_add(3)
7490 > ((*params).cParams.chainLog).wrapping_add(1)
7491 {
7492 ((*params).cParams.hashLog).wrapping_add(3)
7493 } else {
7494 ((*params).cParams.chainLog).wrapping_add(1)
7495 }
7496 } else {
7497 31
7498 });
7499 if srcSize > maxDictSize_0 as size_t {
7500 ip = iend.offset(-(maxDictSize_0 as isize));
7501 src = ip as *const core::ffi::c_void;
7502 srcSize = maxDictSize_0 as size_t;
7503 }
7504 (*ms).nextToUpdate = ip.offset_from((*ms).window.base) as core::ffi::c_long as u32;
7505 (*ms).loadedDictEnd = if (*params).forceWindow != 0 {
7506 0
7507 } else {
7508 iend.offset_from((*ms).window.base) as core::ffi::c_long as u32
7509 };
7510 (*ms).forceNonContiguous = (*params).deterministicRefPrefix;
7511 if srcSize <= HASH_READ_SIZE as size_t {
7512 return 0;
7513 }
7514 ZSTD_overflowCorrectIfNeeded(
7515 ms,
7516 ws,
7517 params,
7518 ip as *const core::ffi::c_void,
7519 iend as *const core::ffi::c_void,
7520 );
7521 match (*params).cParams.strategy as core::ffi::c_uint {
7522 1 => {
7523 ZSTD_fillHashTable(ms, iend as *const core::ffi::c_void, dtlm, tfp);
7524 }
7525 2 => {
7526 ZSTD_fillDoubleHashTable(ms, iend as *const core::ffi::c_void, dtlm, tfp);
7527 }
7528 3..=5 => {
7529 if (*ms).dedicatedDictSearch != 0 {
7530 ZSTD_dedicatedDictSearch_lazy_loadDictionary(
7531 ms,
7532 iend.offset(-(HASH_READ_SIZE as isize)),
7533 );
7534 } else if (*params).useRowMatchFinder as core::ffi::c_uint
7535 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint
7536 {
7537 let tagTableSize = (1) << (*params).cParams.hashLog;
7538 ptr::write_bytes((*ms).tagTable as *mut u8, 0, tagTableSize as usize);
7539 ZSTD_row_update(ms, iend.offset(-(HASH_READ_SIZE as isize)));
7540 } else {
7541 ZSTD_insertAndFindFirstIndex(ms, iend.offset(-(HASH_READ_SIZE as isize)));
7542 }
7543 }
7544 6..=9 => {
7545 ZSTD_updateTree(ms, iend.offset(-(HASH_READ_SIZE as isize)), iend);
7546 }
7547 _ => {}
7548 }
7549 (*ms).nextToUpdate = iend.offset_from((*ms).window.base) as core::ffi::c_long as u32;
7550 0
7551}
7552unsafe fn ZSTD_dictNCountRepeat(
7553 normalizedCounter: *mut core::ffi::c_short,
7554 dictMaxSymbolValue: core::ffi::c_uint,
7555 maxSymbolValue: core::ffi::c_uint,
7556) -> FSE_repeat {
7557 let mut s: u32 = 0;
7558 if dictMaxSymbolValue < maxSymbolValue {
7559 return FSE_repeat_check;
7560 }
7561 s = 0;
7562 while s <= maxSymbolValue {
7563 if *normalizedCounter.offset(s as isize) as core::ffi::c_int == 0 {
7564 return FSE_repeat_check;
7565 }
7566 s = s.wrapping_add(1);
7567 }
7568 FSE_repeat_valid
7569}
7570pub unsafe fn ZSTD_loadCEntropy(
7571 bs: *mut ZSTD_compressedBlockState_t,
7572 workspace: *mut core::ffi::c_void,
7573 dict: *const core::ffi::c_void,
7574 dictSize: size_t,
7575) -> size_t {
7576 let mut offcodeNCount: [core::ffi::c_short; 32] = [0; 32];
7577 let mut offcodeMaxValue = MaxOff as core::ffi::c_uint;
7578 let mut dictPtr = dict as *const u8;
7579 let dictEnd = dictPtr.add(dictSize);
7580 dictPtr = dictPtr.offset(8);
7581 (*bs).entropy.huf.repeatMode = HUF_repeat_check;
7582 let mut maxSymbolValue = 255;
7583 let mut hasZeroWeights = 1;
7584 let hufHeaderSize = HUF_readCTable(
7585 ((*bs).entropy.huf.CTable).as_mut_ptr(),
7586 &mut maxSymbolValue,
7587 dictPtr as *const core::ffi::c_void,
7588 dictEnd.offset_from(dictPtr) as size_t,
7589 &mut hasZeroWeights,
7590 );
7591 if hasZeroWeights == 0 && maxSymbolValue == 255 {
7592 (*bs).entropy.huf.repeatMode = HUF_repeat_valid;
7593 }
7594 if ERR_isError(hufHeaderSize) {
7595 return Error::dictionary_corrupted.to_error_code();
7596 }
7597 dictPtr = dictPtr.add(hufHeaderSize);
7598 let mut offcodeLog: core::ffi::c_uint = 0;
7599 let offcodeHeaderSize = FSE_readNCount(
7600 &mut offcodeNCount,
7601 &mut offcodeMaxValue,
7602 &mut offcodeLog,
7603 dictPtr as *const core::ffi::c_void,
7604 dictEnd.offset_from(dictPtr) as size_t,
7605 );
7606 if ERR_isError(offcodeHeaderSize) {
7607 return Error::dictionary_corrupted.to_error_code();
7608 }
7609 if offcodeLog > 8 {
7610 return Error::dictionary_corrupted.to_error_code();
7611 }
7612 if ERR_isError(FSE_buildCTable_wksp(
7613 ((*bs).entropy.fse.offcodeCTable).as_mut_ptr(),
7614 offcodeNCount.as_mut_ptr(),
7615 31,
7616 offcodeLog,
7617 workspace,
7618 (((8) << 10) + 512) as size_t,
7619 )) {
7620 return Error::dictionary_corrupted.to_error_code();
7621 }
7622 dictPtr = dictPtr.add(offcodeHeaderSize);
7623 let mut matchlengthNCount: [core::ffi::c_short; 53] = [0; 53];
7624 let mut matchlengthMaxValue = MaxML as core::ffi::c_uint;
7625 let mut matchlengthLog: core::ffi::c_uint = 0;
7626 let matchlengthHeaderSize = FSE_readNCount(
7627 &mut matchlengthNCount,
7628 &mut matchlengthMaxValue,
7629 &mut matchlengthLog,
7630 dictPtr as *const core::ffi::c_void,
7631 dictEnd.offset_from(dictPtr) as size_t,
7632 );
7633 if ERR_isError(matchlengthHeaderSize) {
7634 return Error::dictionary_corrupted.to_error_code();
7635 }
7636 if matchlengthLog > 9 {
7637 return Error::dictionary_corrupted.to_error_code();
7638 }
7639 if ERR_isError(FSE_buildCTable_wksp(
7640 ((*bs).entropy.fse.matchlengthCTable).as_mut_ptr(),
7641 matchlengthNCount.as_mut_ptr(),
7642 matchlengthMaxValue,
7643 matchlengthLog,
7644 workspace,
7645 (((8) << 10) + 512) as size_t,
7646 )) {
7647 return Error::dictionary_corrupted.to_error_code();
7648 }
7649 (*bs).entropy.fse.matchlength_repeatMode = ZSTD_dictNCountRepeat(
7650 matchlengthNCount.as_mut_ptr(),
7651 matchlengthMaxValue,
7652 MaxML as core::ffi::c_uint,
7653 );
7654 dictPtr = dictPtr.add(matchlengthHeaderSize);
7655 let mut litlengthNCount: [core::ffi::c_short; 36] = [0; 36];
7656 let mut litlengthMaxValue = MaxLL as core::ffi::c_uint;
7657 let mut litlengthLog: core::ffi::c_uint = 0;
7658 let litlengthHeaderSize = FSE_readNCount(
7659 &mut litlengthNCount,
7660 &mut litlengthMaxValue,
7661 &mut litlengthLog,
7662 dictPtr as *const core::ffi::c_void,
7663 dictEnd.offset_from(dictPtr) as size_t,
7664 );
7665 if ERR_isError(litlengthHeaderSize) {
7666 return Error::dictionary_corrupted.to_error_code();
7667 }
7668 if litlengthLog > 9 {
7669 return Error::dictionary_corrupted.to_error_code();
7670 }
7671 if ERR_isError(FSE_buildCTable_wksp(
7672 ((*bs).entropy.fse.litlengthCTable).as_mut_ptr(),
7673 litlengthNCount.as_mut_ptr(),
7674 litlengthMaxValue,
7675 litlengthLog,
7676 workspace,
7677 (((8) << 10) + 512) as size_t,
7678 )) {
7679 return Error::dictionary_corrupted.to_error_code();
7680 }
7681 (*bs).entropy.fse.litlength_repeatMode = ZSTD_dictNCountRepeat(
7682 litlengthNCount.as_mut_ptr(),
7683 litlengthMaxValue,
7684 MaxLL as core::ffi::c_uint,
7685 );
7686 dictPtr = dictPtr.add(litlengthHeaderSize);
7687 if dictPtr.offset(12) > dictEnd {
7688 return Error::dictionary_corrupted.to_error_code();
7689 }
7690 *((*bs).rep).as_mut_ptr().offset(0) =
7691 MEM_readLE32(dictPtr.offset(0) as *const core::ffi::c_void);
7692 *((*bs).rep).as_mut_ptr().offset(1) =
7693 MEM_readLE32(dictPtr.offset(4) as *const core::ffi::c_void);
7694 *((*bs).rep).as_mut_ptr().offset(2) =
7695 MEM_readLE32(dictPtr.offset(8) as *const core::ffi::c_void);
7696 dictPtr = dictPtr.offset(12);
7697 let dictContentSize = dictEnd.offset_from(dictPtr) as size_t;
7698 let mut offcodeMax = MaxOff as u32;
7699 if dictContentSize
7700 <= (-(1 as core::ffi::c_int) as u32)
7701 .wrapping_sub((128 as core::ffi::c_int * ((1 as core::ffi::c_int) << 10)) as u32)
7702 as size_t
7703 {
7704 let maxOffset = (dictContentSize as u32).wrapping_add((128 * ((1) << 10)) as u32);
7705 offcodeMax = ZSTD_highbit32(maxOffset);
7706 }
7707 (*bs).entropy.fse.offcode_repeatMode = ZSTD_dictNCountRepeat(
7708 offcodeNCount.as_mut_ptr(),
7709 offcodeMaxValue,
7710 if offcodeMax < 31 { offcodeMax } else { 31 },
7711 );
7712 let mut u: u32 = 0;
7713 u = 0;
7714 while u < 3 {
7715 if *((*bs).rep).as_mut_ptr().offset(u as isize) == 0 {
7716 return Error::dictionary_corrupted.to_error_code();
7717 }
7718 if *((*bs).rep).as_mut_ptr().offset(u as isize) as size_t > dictContentSize {
7719 return Error::dictionary_corrupted.to_error_code();
7720 }
7721 u = u.wrapping_add(1);
7722 }
7723 dictPtr.offset_from(dict as *const u8) as size_t
7724}
7725unsafe fn ZSTD_loadZstdDictionary(
7726 bs: *mut ZSTD_compressedBlockState_t,
7727 ms: *mut ZSTD_MatchState_t,
7728 ws: *mut ZSTD_cwksp,
7729 params: *const ZSTD_CCtx_params,
7730 dict: *const core::ffi::c_void,
7731 dictSize: size_t,
7732 dtlm: ZSTD_dictTableLoadMethod_e,
7733 tfp: ZSTD_tableFillPurpose_e,
7734 workspace: *mut core::ffi::c_void,
7735) -> size_t {
7736 let mut dictPtr = dict as *const u8;
7737 let dictEnd = dictPtr.add(dictSize);
7738 let mut dictID: size_t = 0;
7739 let mut eSize: size_t = 0;
7740 dictID = (if (*params).fParams.noDictIDFlag != 0 {
7741 0
7742 } else {
7743 MEM_readLE32(dictPtr.offset(4) as *const core::ffi::c_void)
7744 }) as size_t;
7745 eSize = ZSTD_loadCEntropy(bs, workspace, dict, dictSize);
7746 let err_code = eSize;
7747 if ERR_isError(err_code) {
7748 return err_code;
7749 }
7750 dictPtr = dictPtr.add(eSize);
7751 let dictContentSize = dictEnd.offset_from(dictPtr) as size_t;
7752 let err_code_0 = ZSTD_loadDictionaryContent(
7753 ms,
7754 core::ptr::null_mut::<ldmState_t>(),
7755 ws,
7756 params,
7757 dictPtr as *const core::ffi::c_void,
7758 dictContentSize,
7759 dtlm,
7760 tfp,
7761 );
7762 if ERR_isError(err_code_0) {
7763 return err_code_0;
7764 }
7765 dictID
7766}
7767unsafe fn ZSTD_compress_insertDictionary(
7768 bs: *mut ZSTD_compressedBlockState_t,
7769 ms: *mut ZSTD_MatchState_t,
7770 ls: *mut ldmState_t,
7771 ws: *mut ZSTD_cwksp,
7772 params: *const ZSTD_CCtx_params,
7773 dict: *const core::ffi::c_void,
7774 dictSize: size_t,
7775 dictContentType: ZSTD_dictContentType_e,
7776 dtlm: ZSTD_dictTableLoadMethod_e,
7777 tfp: ZSTD_tableFillPurpose_e,
7778 workspace: *mut core::ffi::c_void,
7779) -> size_t {
7780 if dict.is_null() || dictSize < 8 {
7781 if dictContentType as core::ffi::c_uint
7782 == ZSTD_dct_fullDict as core::ffi::c_int as core::ffi::c_uint
7783 {
7784 return Error::dictionary_wrong.to_error_code();
7785 }
7786 return 0;
7787 }
7788 ZSTD_reset_compressedBlockState(bs);
7789 if dictContentType as core::ffi::c_uint
7790 == ZSTD_dct_rawContent as core::ffi::c_int as core::ffi::c_uint
7791 {
7792 return ZSTD_loadDictionaryContent(ms, ls, ws, params, dict, dictSize, dtlm, tfp);
7793 }
7794 if MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY {
7795 if dictContentType as core::ffi::c_uint
7796 == ZSTD_dct_auto as core::ffi::c_int as core::ffi::c_uint
7797 {
7798 return ZSTD_loadDictionaryContent(ms, ls, ws, params, dict, dictSize, dtlm, tfp);
7799 }
7800 if dictContentType as core::ffi::c_uint
7801 == ZSTD_dct_fullDict as core::ffi::c_int as core::ffi::c_uint
7802 {
7803 return Error::dictionary_wrong.to_error_code();
7804 }
7805 }
7806 ZSTD_loadZstdDictionary(bs, ms, ws, params, dict, dictSize, dtlm, tfp, workspace)
7807}
7808pub const ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF: core::ffi::c_int = 128 * ((1) << 10);
7809pub const ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER: core::ffi::c_ulonglong = 6;
7810unsafe fn ZSTD_compressBegin_internal(
7811 cctx: *mut ZSTD_CCtx,
7812 dict: *const core::ffi::c_void,
7813 dictSize: size_t,
7814 dictContentType: ZSTD_dictContentType_e,
7815 dtlm: ZSTD_dictTableLoadMethod_e,
7816 cdict: *const ZSTD_CDict,
7817 params: *const ZSTD_CCtx_params,
7818 pledgedSrcSize: u64,
7819 zbuff: ZSTD_buffered_policy_e,
7820) -> size_t {
7821 let dictContentSize = if !cdict.is_null() {
7822 (*cdict).dictContentSize
7823 } else {
7824 dictSize
7825 };
7826 (*cctx).traceCtx = ZSTD_trace_compress_begin(cctx);
7827 if !cdict.is_null()
7828 && (*cdict).dictContentSize > 0
7829 && (pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF as u64
7830 || (pledgedSrcSize as core::ffi::c_ulonglong)
7831 < ((*cdict).dictContentSize as core::ffi::c_ulonglong)
7832 .wrapping_mul(ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER)
7833 || pledgedSrcSize as core::ffi::c_ulonglong == ZSTD_CONTENTSIZE_UNKNOWN
7834 || (*cdict).compressionLevel == 0)
7835 && (*params).attachDictPref as core::ffi::c_uint
7836 != ZSTD_dictForceLoad as core::ffi::c_int as core::ffi::c_uint
7837 {
7838 return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);
7839 }
7840 let err_code = ZSTD_resetCCtx_internal(
7841 cctx,
7842 params,
7843 pledgedSrcSize,
7844 dictContentSize,
7845 ZSTDcrp_makeClean,
7846 zbuff,
7847 );
7848 if ERR_isError(err_code) {
7849 return err_code;
7850 }
7851 let dictID = if !cdict.is_null() {
7852 ZSTD_compress_insertDictionary(
7853 (*cctx).blockState.prevCBlock,
7854 &mut (*cctx).blockState.matchState,
7855 &mut (*cctx).ldmState,
7856 &mut (*cctx).workspace,
7857 &(*cctx).appliedParams,
7858 (*cdict).dictContent,
7859 (*cdict).dictContentSize,
7860 (*cdict).dictContentType,
7861 dtlm,
7862 ZSTD_tfp_forCCtx,
7863 (*cctx).tmpWorkspace,
7864 )
7865 } else {
7866 ZSTD_compress_insertDictionary(
7867 (*cctx).blockState.prevCBlock,
7868 &mut (*cctx).blockState.matchState,
7869 &mut (*cctx).ldmState,
7870 &mut (*cctx).workspace,
7871 &(*cctx).appliedParams,
7872 dict,
7873 dictSize,
7874 dictContentType,
7875 dtlm,
7876 ZSTD_tfp_forCCtx,
7877 (*cctx).tmpWorkspace,
7878 )
7879 };
7880 let err_code_0 = dictID;
7881 if ERR_isError(err_code_0) {
7882 return err_code_0;
7883 }
7884 (*cctx).dictID = dictID as u32;
7885 (*cctx).dictContentSize = dictContentSize;
7886 0
7887}
7888pub unsafe fn ZSTD_compressBegin_advanced_internal(
7889 cctx: *mut ZSTD_CCtx,
7890 dict: *const core::ffi::c_void,
7891 dictSize: size_t,
7892 dictContentType: ZSTD_dictContentType_e,
7893 dtlm: ZSTD_dictTableLoadMethod_e,
7894 cdict: *const ZSTD_CDict,
7895 params: *const ZSTD_CCtx_params,
7896 pledgedSrcSize: core::ffi::c_ulonglong,
7897) -> size_t {
7898 let err_code = ZSTD_checkCParams((*params).cParams);
7899 if ERR_isError(err_code) {
7900 return err_code;
7901 }
7902 ZSTD_compressBegin_internal(
7903 cctx,
7904 dict,
7905 dictSize,
7906 dictContentType,
7907 dtlm,
7908 cdict,
7909 params,
7910 pledgedSrcSize,
7911 ZSTDb_not_buffered,
7912 )
7913}
7914#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBegin_advanced))]
7915pub unsafe extern "C" fn ZSTD_compressBegin_advanced(
7916 cctx: *mut ZSTD_CCtx,
7917 dict: *const core::ffi::c_void,
7918 dictSize: size_t,
7919 params: ZSTD_parameters,
7920 pledgedSrcSize: core::ffi::c_ulonglong,
7921) -> size_t {
7922 let mut cctxParams = ZSTD_CCtx_params_s {
7923 format: Format::ZSTD_f_zstd1,
7924 cParams: ZSTD_compressionParameters {
7925 windowLog: 0,
7926 chainLog: 0,
7927 hashLog: 0,
7928 searchLog: 0,
7929 minMatch: 0,
7930 targetLength: 0,
7931 strategy: 0,
7932 },
7933 fParams: ZSTD_frameParameters {
7934 contentSizeFlag: 0,
7935 checksumFlag: 0,
7936 noDictIDFlag: 0,
7937 },
7938 compressionLevel: 0,
7939 forceWindow: 0,
7940 targetCBlockSize: 0,
7941 srcSizeHint: 0,
7942 attachDictPref: ZSTD_dictDefaultAttach,
7943 literalCompressionMode: ZSTD_ps_auto,
7944 nbWorkers: 0,
7945 jobSize: 0,
7946 overlapLog: 0,
7947 rsyncable: 0,
7948 ldmParams: ldmParams_t {
7949 enableLdm: ZSTD_ps_auto,
7950 hashLog: 0,
7951 bucketSizeLog: 0,
7952 minMatchLength: 0,
7953 hashRateLog: 0,
7954 windowLog: 0,
7955 },
7956 enableDedicatedDictSearch: 0,
7957 inBufferMode: ZSTD_bm_buffered,
7958 outBufferMode: ZSTD_bm_buffered,
7959 blockDelimiters: ZSTD_sf_noBlockDelimiters,
7960 validateSequences: 0,
7961 postBlockSplitter: ZSTD_ps_auto,
7962 preBlockSplitter_level: 0,
7963 maxBlockSize: 0,
7964 useRowMatchFinder: ZSTD_ps_auto,
7965 deterministicRefPrefix: 0,
7966 customMem: ZSTD_customMem {
7967 customAlloc: None,
7968 customFree: None,
7969 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
7970 },
7971 prefetchCDictTables: ZSTD_ps_auto,
7972 enableMatchFinderFallback: 0,
7973 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
7974 extSeqProdFunc: None,
7975 searchForExternalRepcodes: ZSTD_ps_auto,
7976 };
7977 ZSTD_CCtxParams_init_internal(&mut cctxParams, ¶ms, ZSTD_NO_CLEVEL);
7978 ZSTD_compressBegin_advanced_internal(
7979 cctx,
7980 dict,
7981 dictSize,
7982 ZSTD_dct_auto,
7983 ZSTD_dtlm_fast,
7984 core::ptr::null(),
7985 &cctxParams,
7986 pledgedSrcSize,
7987 )
7988}
7989unsafe fn ZSTD_compressBegin_usingDict_deprecated(
7990 cctx: *mut ZSTD_CCtx,
7991 dict: *const core::ffi::c_void,
7992 dictSize: size_t,
7993 compressionLevel: core::ffi::c_int,
7994) -> size_t {
7995 let mut cctxParams = ZSTD_CCtx_params_s {
7996 format: Format::ZSTD_f_zstd1,
7997 cParams: ZSTD_compressionParameters {
7998 windowLog: 0,
7999 chainLog: 0,
8000 hashLog: 0,
8001 searchLog: 0,
8002 minMatch: 0,
8003 targetLength: 0,
8004 strategy: 0,
8005 },
8006 fParams: ZSTD_frameParameters {
8007 contentSizeFlag: 0,
8008 checksumFlag: 0,
8009 noDictIDFlag: 0,
8010 },
8011 compressionLevel: 0,
8012 forceWindow: 0,
8013 targetCBlockSize: 0,
8014 srcSizeHint: 0,
8015 attachDictPref: ZSTD_dictDefaultAttach,
8016 literalCompressionMode: ZSTD_ps_auto,
8017 nbWorkers: 0,
8018 jobSize: 0,
8019 overlapLog: 0,
8020 rsyncable: 0,
8021 ldmParams: ldmParams_t {
8022 enableLdm: ZSTD_ps_auto,
8023 hashLog: 0,
8024 bucketSizeLog: 0,
8025 minMatchLength: 0,
8026 hashRateLog: 0,
8027 windowLog: 0,
8028 },
8029 enableDedicatedDictSearch: 0,
8030 inBufferMode: ZSTD_bm_buffered,
8031 outBufferMode: ZSTD_bm_buffered,
8032 blockDelimiters: ZSTD_sf_noBlockDelimiters,
8033 validateSequences: 0,
8034 postBlockSplitter: ZSTD_ps_auto,
8035 preBlockSplitter_level: 0,
8036 maxBlockSize: 0,
8037 useRowMatchFinder: ZSTD_ps_auto,
8038 deterministicRefPrefix: 0,
8039 customMem: ZSTD_customMem {
8040 customAlloc: None,
8041 customFree: None,
8042 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
8043 },
8044 prefetchCDictTables: ZSTD_ps_auto,
8045 enableMatchFinderFallback: 0,
8046 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
8047 extSeqProdFunc: None,
8048 searchForExternalRepcodes: ZSTD_ps_auto,
8049 };
8050 let params = ZSTD_getParams_internal(
8051 compressionLevel,
8052 ZSTD_CONTENTSIZE_UNKNOWN,
8053 dictSize,
8054 ZSTD_cpm_noAttachDict,
8055 );
8056 ZSTD_CCtxParams_init_internal(
8057 &mut cctxParams,
8058 ¶ms,
8059 if compressionLevel == 0 {
8060 ZSTD_CLEVEL_DEFAULT
8061 } else {
8062 compressionLevel
8063 },
8064 );
8065 ZSTD_compressBegin_internal(
8066 cctx,
8067 dict,
8068 dictSize,
8069 ZSTD_dct_auto,
8070 ZSTD_dtlm_fast,
8071 core::ptr::null(),
8072 &cctxParams,
8073 ZSTD_CONTENTSIZE_UNKNOWN,
8074 ZSTDb_not_buffered,
8075 )
8076}
8077#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBegin_usingDict))]
8078pub unsafe extern "C" fn ZSTD_compressBegin_usingDict(
8079 cctx: *mut ZSTD_CCtx,
8080 dict: *const core::ffi::c_void,
8081 dictSize: size_t,
8082 compressionLevel: core::ffi::c_int,
8083) -> size_t {
8084 ZSTD_compressBegin_usingDict_deprecated(cctx, dict, dictSize, compressionLevel)
8085}
8086#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBegin))]
8087pub unsafe extern "C" fn ZSTD_compressBegin(
8088 cctx: *mut ZSTD_CCtx,
8089 compressionLevel: core::ffi::c_int,
8090) -> size_t {
8091 ZSTD_compressBegin_usingDict_deprecated(cctx, core::ptr::null(), 0, compressionLevel)
8092}
8093unsafe fn ZSTD_writeEpilogue(
8094 cctx: *mut ZSTD_CCtx,
8095 dst: *mut core::ffi::c_void,
8096 mut dstCapacity: size_t,
8097) -> size_t {
8098 let ostart = dst as *mut u8;
8099 let mut op = ostart;
8100 if (*cctx).stage as core::ffi::c_uint == ZSTDcs_created as core::ffi::c_int as core::ffi::c_uint
8101 {
8102 return Error::stage_wrong.to_error_code();
8103 }
8104 if (*cctx).stage as core::ffi::c_uint == ZSTDcs_init as core::ffi::c_int as core::ffi::c_uint {
8105 let fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &(*cctx).appliedParams, 0, 0);
8106 let err_code = fhSize;
8107 if ERR_isError(err_code) {
8108 return err_code;
8109 }
8110 dstCapacity = dstCapacity.wrapping_sub(fhSize);
8111 op = op.add(fhSize);
8112 (*cctx).stage = ZSTDcs_ongoing;
8113 }
8114 if (*cctx).stage as core::ffi::c_uint != ZSTDcs_ending as core::ffi::c_int as core::ffi::c_uint
8115 {
8116 let cBlockHeader24 = 1u32
8117 .wrapping_add((bt_raw as core::ffi::c_int as u32) << 1)
8118 .wrapping_add(0);
8119 if dstCapacity < 3 as size_t {
8120 return Error::dstSize_tooSmall.to_error_code();
8121 }
8122 MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader24);
8123 op = op.add(ZSTD_blockHeaderSize);
8124 dstCapacity = dstCapacity.wrapping_sub(ZSTD_blockHeaderSize);
8125 }
8126 if (*cctx).appliedParams.fParams.checksumFlag != 0 {
8127 let checksum = ZSTD_XXH64_digest(&mut (*cctx).xxhState) as u32;
8128 if dstCapacity < 4 {
8129 return Error::dstSize_tooSmall.to_error_code();
8130 }
8131 MEM_writeLE32(op as *mut core::ffi::c_void, checksum);
8132 op = op.offset(4);
8133 }
8134 (*cctx).stage = ZSTDcs_created;
8135 op.offset_from(ostart) as size_t
8136}
8137pub unsafe fn ZSTD_CCtx_trace(cctx: *mut ZSTD_CCtx, extraCSize: size_t) {
8138 if (*cctx).traceCtx != 0 {
8139 let streaming = ((*cctx).inBuffSize > 0
8140 || (*cctx).outBuffSize > 0
8141 || (*cctx).appliedParams.nbWorkers > 0) as core::ffi::c_int;
8142 let mut trace = ZSTD_Trace {
8143 version: 0,
8144 streaming: 0,
8145 dictionaryID: 0,
8146 dictionaryIsCold: 0,
8147 dictionarySize: 0,
8148 uncompressedSize: 0,
8149 compressedSize: 0,
8150 params: core::ptr::null(),
8151 cctx: core::ptr::null(),
8152 dctx: core::ptr::null(),
8153 };
8154 ptr::write_bytes(
8155 &mut trace as *mut ZSTD_Trace as *mut u8,
8156 0,
8157 ::core::mem::size_of::<ZSTD_Trace>(),
8158 );
8159 trace.version = ZSTD_VERSION_NUMBER as core::ffi::c_uint;
8160 trace.streaming = streaming;
8161 trace.dictionaryID = (*cctx).dictID;
8162 trace.dictionarySize = (*cctx).dictContentSize;
8163 trace.uncompressedSize = (*cctx).consumedSrcSize as size_t;
8164 trace.compressedSize =
8165 ((*cctx).producedCSize).wrapping_add(extraCSize as core::ffi::c_ulonglong) as size_t;
8166 trace.params = &mut (*cctx).appliedParams;
8167 trace.cctx = cctx;
8168 ZSTD_trace_compress_end((*cctx).traceCtx, &mut trace);
8169 }
8170 (*cctx).traceCtx = 0;
8171}
8172#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressEnd_public))]
8173pub unsafe extern "C" fn ZSTD_compressEnd_public(
8174 cctx: *mut ZSTD_CCtx,
8175 dst: *mut core::ffi::c_void,
8176 dstCapacity: size_t,
8177 src: *const core::ffi::c_void,
8178 srcSize: size_t,
8179) -> size_t {
8180 let mut endResult: size_t = 0;
8181 let cSize = ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1, 1);
8182 let err_code = cSize;
8183 if ERR_isError(err_code) {
8184 return err_code;
8185 }
8186 endResult = ZSTD_writeEpilogue(
8187 cctx,
8188 (dst as *mut core::ffi::c_char).add(cSize) as *mut core::ffi::c_void,
8189 dstCapacity.wrapping_sub(cSize),
8190 );
8191 let err_code_0 = endResult;
8192 if ERR_isError(err_code_0) {
8193 return err_code_0;
8194 }
8195 if (*cctx).pledgedSrcSizePlusOne != 0
8196 && (*cctx).pledgedSrcSizePlusOne != ((*cctx).consumedSrcSize).wrapping_add(1)
8197 {
8198 return Error::srcSize_wrong.to_error_code();
8199 }
8200 ZSTD_CCtx_trace(cctx, endResult);
8201 cSize.wrapping_add(endResult)
8202}
8203#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressEnd))]
8204pub unsafe extern "C" fn ZSTD_compressEnd(
8205 cctx: *mut ZSTD_CCtx,
8206 dst: *mut core::ffi::c_void,
8207 dstCapacity: size_t,
8208 src: *const core::ffi::c_void,
8209 srcSize: size_t,
8210) -> size_t {
8211 ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize)
8212}
8213#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compress_advanced))]
8214pub unsafe extern "C" fn ZSTD_compress_advanced(
8215 cctx: *mut ZSTD_CCtx,
8216 dst: *mut core::ffi::c_void,
8217 dstCapacity: size_t,
8218 src: *const core::ffi::c_void,
8219 srcSize: size_t,
8220 dict: *const core::ffi::c_void,
8221 dictSize: size_t,
8222 params: ZSTD_parameters,
8223) -> size_t {
8224 let err_code = ZSTD_checkCParams(params.cParams);
8225 if ERR_isError(err_code) {
8226 return err_code;
8227 }
8228 ZSTD_CCtxParams_init_internal(&mut (*cctx).simpleApiParams, ¶ms, ZSTD_NO_CLEVEL);
8229 ZSTD_compress_advanced_internal(
8230 cctx,
8231 dst,
8232 dstCapacity,
8233 src,
8234 srcSize,
8235 dict,
8236 dictSize,
8237 &(*cctx).simpleApiParams,
8238 )
8239}
8240pub unsafe fn ZSTD_compress_advanced_internal(
8241 cctx: *mut ZSTD_CCtx,
8242 dst: *mut core::ffi::c_void,
8243 dstCapacity: size_t,
8244 src: *const core::ffi::c_void,
8245 srcSize: size_t,
8246 dict: *const core::ffi::c_void,
8247 dictSize: size_t,
8248 params: *const ZSTD_CCtx_params,
8249) -> size_t {
8250 let err_code = ZSTD_compressBegin_internal(
8251 cctx,
8252 dict,
8253 dictSize,
8254 ZSTD_dct_auto,
8255 ZSTD_dtlm_fast,
8256 core::ptr::null::<ZSTD_CDict>(),
8257 params,
8258 srcSize as u64,
8259 ZSTDb_not_buffered,
8260 );
8261 if ERR_isError(err_code) {
8262 return err_code;
8263 }
8264 ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize)
8265}
8266#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compress_usingDict))]
8267pub unsafe extern "C" fn ZSTD_compress_usingDict(
8268 cctx: *mut ZSTD_CCtx,
8269 dst: *mut core::ffi::c_void,
8270 dstCapacity: size_t,
8271 src: *const core::ffi::c_void,
8272 srcSize: size_t,
8273 dict: *const core::ffi::c_void,
8274 dictSize: size_t,
8275 compressionLevel: core::ffi::c_int,
8276) -> size_t {
8277 let params = ZSTD_getParams_internal(
8278 compressionLevel,
8279 srcSize as core::ffi::c_ulonglong,
8280 if !dict.is_null() { dictSize } else { 0 },
8281 ZSTD_cpm_noAttachDict,
8282 );
8283 ZSTD_CCtxParams_init_internal(
8284 &mut (*cctx).simpleApiParams,
8285 ¶ms,
8286 if compressionLevel == 0 {
8287 ZSTD_CLEVEL_DEFAULT
8288 } else {
8289 compressionLevel
8290 },
8291 );
8292 ZSTD_compress_advanced_internal(
8293 cctx,
8294 dst,
8295 dstCapacity,
8296 src,
8297 srcSize,
8298 dict,
8299 dictSize,
8300 &(*cctx).simpleApiParams,
8301 )
8302}
8303#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressCCtx))]
8304pub unsafe extern "C" fn ZSTD_compressCCtx(
8305 cctx: *mut ZSTD_CCtx,
8306 dst: *mut core::ffi::c_void,
8307 dstCapacity: size_t,
8308 src: *const core::ffi::c_void,
8309 srcSize: size_t,
8310 compressionLevel: core::ffi::c_int,
8311) -> size_t {
8312 ZSTD_compress_usingDict(
8313 cctx,
8314 dst,
8315 dstCapacity,
8316 src,
8317 srcSize,
8318 core::ptr::null(),
8319 0,
8320 compressionLevel,
8321 )
8322}
8323#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compress))]
8324pub unsafe extern "C" fn ZSTD_compress(
8325 dst: *mut core::ffi::c_void,
8326 dstCapacity: size_t,
8327 src: *const core::ffi::c_void,
8328 srcSize: size_t,
8329 compressionLevel: core::ffi::c_int,
8330) -> size_t {
8331 let mut result: size_t = 0;
8332 let mut ctxBody = ZSTD_CCtx_s {
8333 stage: ZSTDcs_created,
8334 cParamsChanged: 0,
8335 bmi2: 0,
8336 requestedParams: ZSTD_CCtx_params_s {
8337 format: Format::ZSTD_f_zstd1,
8338 cParams: ZSTD_compressionParameters {
8339 windowLog: 0,
8340 chainLog: 0,
8341 hashLog: 0,
8342 searchLog: 0,
8343 minMatch: 0,
8344 targetLength: 0,
8345 strategy: 0,
8346 },
8347 fParams: ZSTD_frameParameters {
8348 contentSizeFlag: 0,
8349 checksumFlag: 0,
8350 noDictIDFlag: 0,
8351 },
8352 compressionLevel: 0,
8353 forceWindow: 0,
8354 targetCBlockSize: 0,
8355 srcSizeHint: 0,
8356 attachDictPref: ZSTD_dictDefaultAttach,
8357 literalCompressionMode: ZSTD_ps_auto,
8358 nbWorkers: 0,
8359 jobSize: 0,
8360 overlapLog: 0,
8361 rsyncable: 0,
8362 ldmParams: ldmParams_t {
8363 enableLdm: ZSTD_ps_auto,
8364 hashLog: 0,
8365 bucketSizeLog: 0,
8366 minMatchLength: 0,
8367 hashRateLog: 0,
8368 windowLog: 0,
8369 },
8370 enableDedicatedDictSearch: 0,
8371 inBufferMode: ZSTD_bm_buffered,
8372 outBufferMode: ZSTD_bm_buffered,
8373 blockDelimiters: ZSTD_sf_noBlockDelimiters,
8374 validateSequences: 0,
8375 postBlockSplitter: ZSTD_ps_auto,
8376 preBlockSplitter_level: 0,
8377 maxBlockSize: 0,
8378 useRowMatchFinder: ZSTD_ps_auto,
8379 deterministicRefPrefix: 0,
8380 customMem: ZSTD_customMem {
8381 customAlloc: None,
8382 customFree: None,
8383 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
8384 },
8385 prefetchCDictTables: ZSTD_ps_auto,
8386 enableMatchFinderFallback: 0,
8387 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
8388 extSeqProdFunc: None,
8389 searchForExternalRepcodes: ZSTD_ps_auto,
8390 },
8391 appliedParams: ZSTD_CCtx_params_s {
8392 format: Format::ZSTD_f_zstd1,
8393 cParams: ZSTD_compressionParameters {
8394 windowLog: 0,
8395 chainLog: 0,
8396 hashLog: 0,
8397 searchLog: 0,
8398 minMatch: 0,
8399 targetLength: 0,
8400 strategy: 0,
8401 },
8402 fParams: ZSTD_frameParameters {
8403 contentSizeFlag: 0,
8404 checksumFlag: 0,
8405 noDictIDFlag: 0,
8406 },
8407 compressionLevel: 0,
8408 forceWindow: 0,
8409 targetCBlockSize: 0,
8410 srcSizeHint: 0,
8411 attachDictPref: ZSTD_dictDefaultAttach,
8412 literalCompressionMode: ZSTD_ps_auto,
8413 nbWorkers: 0,
8414 jobSize: 0,
8415 overlapLog: 0,
8416 rsyncable: 0,
8417 ldmParams: ldmParams_t {
8418 enableLdm: ZSTD_ps_auto,
8419 hashLog: 0,
8420 bucketSizeLog: 0,
8421 minMatchLength: 0,
8422 hashRateLog: 0,
8423 windowLog: 0,
8424 },
8425 enableDedicatedDictSearch: 0,
8426 inBufferMode: ZSTD_bm_buffered,
8427 outBufferMode: ZSTD_bm_buffered,
8428 blockDelimiters: ZSTD_sf_noBlockDelimiters,
8429 validateSequences: 0,
8430 postBlockSplitter: ZSTD_ps_auto,
8431 preBlockSplitter_level: 0,
8432 maxBlockSize: 0,
8433 useRowMatchFinder: ZSTD_ps_auto,
8434 deterministicRefPrefix: 0,
8435 customMem: ZSTD_customMem {
8436 customAlloc: None,
8437 customFree: None,
8438 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
8439 },
8440 prefetchCDictTables: ZSTD_ps_auto,
8441 enableMatchFinderFallback: 0,
8442 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
8443 extSeqProdFunc: None,
8444 searchForExternalRepcodes: ZSTD_ps_auto,
8445 },
8446 simpleApiParams: ZSTD_CCtx_params_s {
8447 format: Format::ZSTD_f_zstd1,
8448 cParams: ZSTD_compressionParameters {
8449 windowLog: 0,
8450 chainLog: 0,
8451 hashLog: 0,
8452 searchLog: 0,
8453 minMatch: 0,
8454 targetLength: 0,
8455 strategy: 0,
8456 },
8457 fParams: ZSTD_frameParameters {
8458 contentSizeFlag: 0,
8459 checksumFlag: 0,
8460 noDictIDFlag: 0,
8461 },
8462 compressionLevel: 0,
8463 forceWindow: 0,
8464 targetCBlockSize: 0,
8465 srcSizeHint: 0,
8466 attachDictPref: ZSTD_dictDefaultAttach,
8467 literalCompressionMode: ZSTD_ps_auto,
8468 nbWorkers: 0,
8469 jobSize: 0,
8470 overlapLog: 0,
8471 rsyncable: 0,
8472 ldmParams: ldmParams_t {
8473 enableLdm: ZSTD_ps_auto,
8474 hashLog: 0,
8475 bucketSizeLog: 0,
8476 minMatchLength: 0,
8477 hashRateLog: 0,
8478 windowLog: 0,
8479 },
8480 enableDedicatedDictSearch: 0,
8481 inBufferMode: ZSTD_bm_buffered,
8482 outBufferMode: ZSTD_bm_buffered,
8483 blockDelimiters: ZSTD_sf_noBlockDelimiters,
8484 validateSequences: 0,
8485 postBlockSplitter: ZSTD_ps_auto,
8486 preBlockSplitter_level: 0,
8487 maxBlockSize: 0,
8488 useRowMatchFinder: ZSTD_ps_auto,
8489 deterministicRefPrefix: 0,
8490 customMem: ZSTD_customMem {
8491 customAlloc: None,
8492 customFree: None,
8493 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
8494 },
8495 prefetchCDictTables: ZSTD_ps_auto,
8496 enableMatchFinderFallback: 0,
8497 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
8498 extSeqProdFunc: None,
8499 searchForExternalRepcodes: ZSTD_ps_auto,
8500 },
8501 dictID: 0,
8502 dictContentSize: 0,
8503 workspace: ZSTD_cwksp {
8504 workspace: core::ptr::null_mut::<core::ffi::c_void>(),
8505 workspaceEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8506 objectEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8507 tableEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8508 tableValidEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8509 allocStart: core::ptr::null_mut::<core::ffi::c_void>(),
8510 initOnceStart: core::ptr::null_mut::<core::ffi::c_void>(),
8511 allocFailed: 0,
8512 workspaceOversizedDuration: 0,
8513 phase: ZSTD_cwksp_alloc_objects,
8514 isStatic: ZSTD_cwksp_dynamic_alloc,
8515 },
8516 blockSizeMax: 0,
8517 pledgedSrcSizePlusOne: 0,
8518 consumedSrcSize: 0,
8519 producedCSize: 0,
8520 xxhState: XXH64_state_t::default(),
8521 customMem: ZSTD_customMem {
8522 customAlloc: None,
8523 customFree: None,
8524 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
8525 },
8526 pool: core::ptr::null_mut::<ZSTD_threadPool>(),
8527 staticSize: 0,
8528 seqCollector: SeqCollector {
8529 collectSequences: 0,
8530 seqStart: core::ptr::null_mut::<ZSTD_Sequence>(),
8531 seqIndex: 0,
8532 maxSequences: 0,
8533 },
8534 isFirstBlock: 0,
8535 initialized: 0,
8536 seqStore: SeqStore_t {
8537 sequencesStart: core::ptr::null_mut::<SeqDef>(),
8538 sequences: core::ptr::null_mut::<SeqDef>(),
8539 litStart: core::ptr::null_mut::<u8>(),
8540 lit: core::ptr::null_mut::<u8>(),
8541 llCode: core::ptr::null_mut::<u8>(),
8542 mlCode: core::ptr::null_mut::<u8>(),
8543 ofCode: core::ptr::null_mut::<u8>(),
8544 maxNbSeq: 0,
8545 maxNbLit: 0,
8546 longLengthType: ZSTD_llt_none,
8547 longLengthPos: 0,
8548 },
8549 ldmState: ldmState_t {
8550 window: ZSTD_window_t {
8551 nextSrc: core::ptr::null::<u8>(),
8552 base: core::ptr::null::<u8>(),
8553 dictBase: core::ptr::null::<u8>(),
8554 dictLimit: 0,
8555 lowLimit: 0,
8556 nbOverflowCorrections: 0,
8557 },
8558 hashTable: core::ptr::null_mut::<ldmEntry_t>(),
8559 loadedDictEnd: 0,
8560 bucketOffsets: core::ptr::null_mut::<u8>(),
8561 splitIndices: [0; 64],
8562 matchCandidates: [ldmMatchCandidate_t {
8563 split: core::ptr::null::<u8>(),
8564 hash: 0,
8565 checksum: 0,
8566 bucket: core::ptr::null_mut::<ldmEntry_t>(),
8567 }; 64],
8568 },
8569 ldmSequences: core::ptr::null_mut::<rawSeq>(),
8570 maxNbLdmSequences: 0,
8571 externSeqStore: RawSeqStore_t {
8572 seq: core::ptr::null_mut::<rawSeq>(),
8573 pos: 0,
8574 posInSequence: 0,
8575 size: 0,
8576 capacity: 0,
8577 },
8578 blockState: ZSTD_blockState_t {
8579 prevCBlock: core::ptr::null_mut::<ZSTD_compressedBlockState_t>(),
8580 nextCBlock: core::ptr::null_mut::<ZSTD_compressedBlockState_t>(),
8581 matchState: ZSTD_MatchState_t {
8582 window: ZSTD_window_t {
8583 nextSrc: core::ptr::null::<u8>(),
8584 base: core::ptr::null::<u8>(),
8585 dictBase: core::ptr::null::<u8>(),
8586 dictLimit: 0,
8587 lowLimit: 0,
8588 nbOverflowCorrections: 0,
8589 },
8590 loadedDictEnd: 0,
8591 nextToUpdate: 0,
8592 hashLog3: 0,
8593 rowHashLog: 0,
8594 tagTable: core::ptr::null_mut::<u8>(),
8595 hashCache: [0; 8],
8596 hashSalt: 0,
8597 hashSaltEntropy: 0,
8598 hashTable: core::ptr::null_mut::<u32>(),
8599 hashTable3: core::ptr::null_mut::<u32>(),
8600 chainTable: core::ptr::null_mut::<u32>(),
8601 forceNonContiguous: 0,
8602 dedicatedDictSearch: 0,
8603 opt: optState_t {
8604 litFreq: core::ptr::null_mut::<core::ffi::c_uint>(),
8605 litLengthFreq: core::ptr::null_mut::<core::ffi::c_uint>(),
8606 matchLengthFreq: core::ptr::null_mut::<core::ffi::c_uint>(),
8607 offCodeFreq: core::ptr::null_mut::<core::ffi::c_uint>(),
8608 matchTable: core::ptr::null_mut::<ZSTD_match_t>(),
8609 priceTable: core::ptr::null_mut::<ZSTD_optimal_t>(),
8610 litSum: 0,
8611 litLengthSum: 0,
8612 matchLengthSum: 0,
8613 offCodeSum: 0,
8614 litSumBasePrice: 0,
8615 litLengthSumBasePrice: 0,
8616 matchLengthSumBasePrice: 0,
8617 offCodeSumBasePrice: 0,
8618 priceType: zop_dynamic,
8619 symbolCosts: core::ptr::null::<ZSTD_entropyCTables_t>(),
8620 literalCompressionMode: ZSTD_ps_auto,
8621 },
8622 dictMatchState: core::ptr::null::<ZSTD_MatchState_t>(),
8623 cParams: ZSTD_compressionParameters {
8624 windowLog: 0,
8625 chainLog: 0,
8626 hashLog: 0,
8627 searchLog: 0,
8628 minMatch: 0,
8629 targetLength: 0,
8630 strategy: 0,
8631 },
8632 ldmSeqStore: core::ptr::null::<RawSeqStore_t>(),
8633 prefetchCDictTables: 0,
8634 lazySkipping: 0,
8635 },
8636 },
8637 tmpWorkspace: core::ptr::null_mut::<core::ffi::c_void>(),
8638 tmpWkspSize: 0,
8639 bufferedPolicy: ZSTDb_not_buffered,
8640 inBuff: core::ptr::null_mut::<core::ffi::c_char>(),
8641 inBuffSize: 0,
8642 inToCompress: 0,
8643 inBuffPos: 0,
8644 inBuffTarget: 0,
8645 outBuff: core::ptr::null_mut::<core::ffi::c_char>(),
8646 outBuffSize: 0,
8647 outBuffContentSize: 0,
8648 outBuffFlushedSize: 0,
8649 streamStage: zcss_init,
8650 frameEnded: 0,
8651 expectedInBuffer: ZSTD_inBuffer_s {
8652 src: core::ptr::null::<core::ffi::c_void>(),
8653 size: 0,
8654 pos: 0,
8655 },
8656 stableIn_notConsumed: 0,
8657 expectedOutBufferSize: 0,
8658 localDict: ZSTD_localDict {
8659 dictBuffer: core::ptr::null_mut::<core::ffi::c_void>(),
8660 dict: core::ptr::null::<core::ffi::c_void>(),
8661 dictSize: 0,
8662 dictContentType: ZSTD_dct_auto,
8663 cdict: core::ptr::null_mut::<ZSTD_CDict>(),
8664 },
8665 cdict: core::ptr::null::<ZSTD_CDict>(),
8666 prefixDict: ZSTD_prefixDict_s {
8667 dict: core::ptr::null::<core::ffi::c_void>(),
8668 dictSize: 0,
8669 dictContentType: ZSTD_dct_auto,
8670 },
8671 mtctx: core::ptr::null_mut::<ZSTDMT_CCtx>(),
8672 traceCtx: 0,
8673 blockSplitCtx: ZSTD_blockSplitCtx {
8674 fullSeqStoreChunk: SeqStore_t {
8675 sequencesStart: core::ptr::null_mut::<SeqDef>(),
8676 sequences: core::ptr::null_mut::<SeqDef>(),
8677 litStart: core::ptr::null_mut::<u8>(),
8678 lit: core::ptr::null_mut::<u8>(),
8679 llCode: core::ptr::null_mut::<u8>(),
8680 mlCode: core::ptr::null_mut::<u8>(),
8681 ofCode: core::ptr::null_mut::<u8>(),
8682 maxNbSeq: 0,
8683 maxNbLit: 0,
8684 longLengthType: ZSTD_llt_none,
8685 longLengthPos: 0,
8686 },
8687 firstHalfSeqStore: SeqStore_t {
8688 sequencesStart: core::ptr::null_mut::<SeqDef>(),
8689 sequences: core::ptr::null_mut::<SeqDef>(),
8690 litStart: core::ptr::null_mut::<u8>(),
8691 lit: core::ptr::null_mut::<u8>(),
8692 llCode: core::ptr::null_mut::<u8>(),
8693 mlCode: core::ptr::null_mut::<u8>(),
8694 ofCode: core::ptr::null_mut::<u8>(),
8695 maxNbSeq: 0,
8696 maxNbLit: 0,
8697 longLengthType: ZSTD_llt_none,
8698 longLengthPos: 0,
8699 },
8700 secondHalfSeqStore: SeqStore_t {
8701 sequencesStart: core::ptr::null_mut::<SeqDef>(),
8702 sequences: core::ptr::null_mut::<SeqDef>(),
8703 litStart: core::ptr::null_mut::<u8>(),
8704 lit: core::ptr::null_mut::<u8>(),
8705 llCode: core::ptr::null_mut::<u8>(),
8706 mlCode: core::ptr::null_mut::<u8>(),
8707 ofCode: core::ptr::null_mut::<u8>(),
8708 maxNbSeq: 0,
8709 maxNbLit: 0,
8710 longLengthType: ZSTD_llt_none,
8711 longLengthPos: 0,
8712 },
8713 currSeqStore: SeqStore_t {
8714 sequencesStart: core::ptr::null_mut::<SeqDef>(),
8715 sequences: core::ptr::null_mut::<SeqDef>(),
8716 litStart: core::ptr::null_mut::<u8>(),
8717 lit: core::ptr::null_mut::<u8>(),
8718 llCode: core::ptr::null_mut::<u8>(),
8719 mlCode: core::ptr::null_mut::<u8>(),
8720 ofCode: core::ptr::null_mut::<u8>(),
8721 maxNbSeq: 0,
8722 maxNbLit: 0,
8723 longLengthType: ZSTD_llt_none,
8724 longLengthPos: 0,
8725 },
8726 nextSeqStore: SeqStore_t {
8727 sequencesStart: core::ptr::null_mut::<SeqDef>(),
8728 sequences: core::ptr::null_mut::<SeqDef>(),
8729 litStart: core::ptr::null_mut::<u8>(),
8730 lit: core::ptr::null_mut::<u8>(),
8731 llCode: core::ptr::null_mut::<u8>(),
8732 mlCode: core::ptr::null_mut::<u8>(),
8733 ofCode: core::ptr::null_mut::<u8>(),
8734 maxNbSeq: 0,
8735 maxNbLit: 0,
8736 longLengthType: ZSTD_llt_none,
8737 longLengthPos: 0,
8738 },
8739 partitions: [0; 196],
8740 entropyMetadata: ZSTD_entropyCTablesMetadata_t {
8741 hufMetadata: ZSTD_hufCTablesMetadata_t {
8742 hType: set_basic,
8743 hufDesBuffer: [0; 128],
8744 hufDesSize: 0,
8745 },
8746 fseMetadata: ZSTD_fseCTablesMetadata_t {
8747 llType: set_basic,
8748 ofType: set_basic,
8749 mlType: set_basic,
8750 fseTablesBuffer: [0; 133],
8751 fseTablesSize: 0,
8752 lastCountSize: 0,
8753 },
8754 },
8755 },
8756 extSeqBuf: core::ptr::null_mut::<ZSTD_Sequence>(),
8757 extSeqBufCapacity: 0,
8758 };
8759 ZSTD_initCCtx(&mut ctxBody, ZSTD_defaultCMem);
8760 result = ZSTD_compressCCtx(
8761 &mut ctxBody,
8762 dst,
8763 dstCapacity,
8764 src,
8765 srcSize,
8766 compressionLevel,
8767 );
8768 ZSTD_freeCCtxContent(&mut ctxBody);
8769 result
8770}
8771#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCDictSize_advanced))]
8772pub unsafe extern "C" fn ZSTD_estimateCDictSize_advanced(
8773 dictSize: size_t,
8774 cParams: ZSTD_compressionParameters,
8775 dictLoadMethod: ZSTD_dictLoadMethod_e,
8776) -> size_t {
8777 (ZSTD_cwksp_alloc_size(::core::mem::size_of::<ZSTD_CDict>()))
8778 .wrapping_add(ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE as size_t))
8779 .wrapping_add(ZSTD_sizeof_matchState(
8780 &cParams,
8781 ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams),
8782 1,
8783 0,
8784 ))
8785 .wrapping_add(
8786 if dictLoadMethod as core::ffi::c_uint
8787 == ZSTD_dlm_byRef as core::ffi::c_int as core::ffi::c_uint
8788 {
8789 0
8790 } else {
8791 ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(
8792 dictSize,
8793 ::core::mem::size_of::<*mut core::ffi::c_void>(),
8794 ))
8795 },
8796 )
8797}
8798#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCDictSize))]
8799pub unsafe extern "C" fn ZSTD_estimateCDictSize(
8800 dictSize: size_t,
8801 compressionLevel: core::ffi::c_int,
8802) -> size_t {
8803 let cParams = ZSTD_getCParams_internal(
8804 compressionLevel,
8805 ZSTD_CONTENTSIZE_UNKNOWN,
8806 dictSize,
8807 ZSTD_cpm_createCDict,
8808 );
8809 ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy)
8810}
8811#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_sizeof_CDict))]
8812pub unsafe extern "C" fn ZSTD_sizeof_CDict(cdict: *const ZSTD_CDict) -> size_t {
8813 if cdict.is_null() {
8814 return 0;
8815 }
8816 (if (*cdict).workspace.workspace == cdict as *mut core::ffi::c_void {
8817 0
8818 } else {
8819 ::core::mem::size_of::<ZSTD_CDict>()
8820 })
8821 .wrapping_add(ZSTD_cwksp_sizeof(&(*cdict).workspace))
8822}
8823unsafe fn ZSTD_initCDict_internal(
8824 cdict: *mut ZSTD_CDict,
8825 dictBuffer: *const core::ffi::c_void,
8826 dictSize: size_t,
8827 dictLoadMethod: ZSTD_dictLoadMethod_e,
8828 dictContentType: ZSTD_dictContentType_e,
8829 mut params: ZSTD_CCtx_params,
8830) -> size_t {
8831 (*cdict).matchState.cParams = params.cParams;
8832 (*cdict).matchState.dedicatedDictSearch = params.enableDedicatedDictSearch;
8833 if dictLoadMethod as core::ffi::c_uint
8834 == ZSTD_dlm_byRef as core::ffi::c_int as core::ffi::c_uint
8835 || dictBuffer.is_null()
8836 || dictSize == 0
8837 {
8838 (*cdict).dictContent = dictBuffer;
8839 } else {
8840 let internalBuffer = ZSTD_cwksp_reserve_object(
8841 &mut (*cdict).workspace,
8842 ZSTD_cwksp_align(dictSize, ::core::mem::size_of::<*mut core::ffi::c_void>()),
8843 );
8844 if internalBuffer.is_null() {
8845 return Error::memory_allocation.to_error_code();
8846 }
8847 (*cdict).dictContent = internalBuffer;
8848 libc::memcpy(internalBuffer, dictBuffer, dictSize as libc::size_t);
8849 }
8850 (*cdict).dictContentSize = dictSize;
8851 (*cdict).dictContentType = dictContentType;
8852 (*cdict).entropyWorkspace =
8853 ZSTD_cwksp_reserve_object(&mut (*cdict).workspace, HUF_WORKSPACE_SIZE as size_t)
8854 as *mut u32;
8855 ZSTD_reset_compressedBlockState(&mut (*cdict).cBlockState);
8856 let err_code = ZSTD_reset_matchState(
8857 &mut (*cdict).matchState,
8858 &mut (*cdict).workspace,
8859 ¶ms.cParams,
8860 params.useRowMatchFinder,
8861 ZSTDcrp_makeClean,
8862 ZSTDirp_reset,
8863 ZSTD_resetTarget_CDict,
8864 );
8865 if ERR_isError(err_code) {
8866 return err_code;
8867 }
8868 params.compressionLevel = ZSTD_CLEVEL_DEFAULT;
8869 params.fParams.contentSizeFlag = 1;
8870 let dictID = ZSTD_compress_insertDictionary(
8871 &mut (*cdict).cBlockState,
8872 &mut (*cdict).matchState,
8873 core::ptr::null_mut(),
8874 &mut (*cdict).workspace,
8875 ¶ms,
8876 (*cdict).dictContent,
8877 (*cdict).dictContentSize,
8878 dictContentType,
8879 ZSTD_dtlm_full,
8880 ZSTD_tfp_forCDict,
8881 (*cdict).entropyWorkspace as *mut core::ffi::c_void,
8882 );
8883 let err_code_0 = dictID;
8884 if ERR_isError(err_code_0) {
8885 return err_code_0;
8886 }
8887 (*cdict).dictID = dictID as u32;
8888 0
8889}
8890unsafe fn ZSTD_createCDict_advanced_internal(
8891 dictSize: size_t,
8892 dictLoadMethod: ZSTD_dictLoadMethod_e,
8893 cParams: ZSTD_compressionParameters,
8894 useRowMatchFinder: ZSTD_ParamSwitch_e,
8895 enableDedicatedDictSearch: core::ffi::c_int,
8896 customMem: ZSTD_customMem,
8897) -> *mut ZSTD_CDict {
8898 if (customMem.customAlloc).is_none() as core::ffi::c_int
8899 ^ (customMem.customFree).is_none() as core::ffi::c_int
8900 != 0
8901 {
8902 return core::ptr::null_mut();
8903 }
8904 let workspaceSize = (ZSTD_cwksp_alloc_size(::core::mem::size_of::<ZSTD_CDict>()))
8905 .wrapping_add(ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE as size_t))
8906 .wrapping_add(ZSTD_sizeof_matchState(
8907 &cParams,
8908 useRowMatchFinder,
8909 enableDedicatedDictSearch,
8910 0,
8911 ))
8912 .wrapping_add(
8913 if dictLoadMethod as core::ffi::c_uint
8914 == ZSTD_dlm_byRef as core::ffi::c_int as core::ffi::c_uint
8915 {
8916 0
8917 } else {
8918 ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(
8919 dictSize,
8920 ::core::mem::size_of::<*mut core::ffi::c_void>(),
8921 ))
8922 },
8923 );
8924 let workspace = ZSTD_customMalloc(workspaceSize, customMem);
8925 let mut ws = ZSTD_cwksp {
8926 workspace: core::ptr::null_mut::<core::ffi::c_void>(),
8927 workspaceEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8928 objectEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8929 tableEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8930 tableValidEnd: core::ptr::null_mut::<core::ffi::c_void>(),
8931 allocStart: core::ptr::null_mut::<core::ffi::c_void>(),
8932 initOnceStart: core::ptr::null_mut::<core::ffi::c_void>(),
8933 allocFailed: 0,
8934 workspaceOversizedDuration: 0,
8935 phase: ZSTD_cwksp_alloc_objects,
8936 isStatic: ZSTD_cwksp_dynamic_alloc,
8937 };
8938 let mut cdict = core::ptr::null_mut::<ZSTD_CDict>();
8939 if workspace.is_null() {
8940 ZSTD_customFree(workspace, customMem);
8941 return core::ptr::null_mut();
8942 }
8943 ZSTD_cwksp_init(&mut ws, workspace, workspaceSize, ZSTD_cwksp_dynamic_alloc);
8944 cdict =
8945 ZSTD_cwksp_reserve_object(&mut ws, ::core::mem::size_of::<ZSTD_CDict>()) as *mut ZSTD_CDict;
8946 ZSTD_cwksp_move(&mut (*cdict).workspace, &mut ws);
8947 (*cdict).customMem = customMem;
8948 (*cdict).compressionLevel = ZSTD_NO_CLEVEL;
8949 (*cdict).useRowMatchFinder = useRowMatchFinder;
8950 cdict
8951}
8952#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCDict_advanced))]
8953pub unsafe extern "C" fn ZSTD_createCDict_advanced(
8954 dictBuffer: *const core::ffi::c_void,
8955 dictSize: size_t,
8956 dictLoadMethod: ZSTD_dictLoadMethod_e,
8957 dictContentType: ZSTD_dictContentType_e,
8958 cParams: ZSTD_compressionParameters,
8959 customMem: ZSTD_customMem,
8960) -> *mut ZSTD_CDict {
8961 let mut cctxParams = ZSTD_CCtx_params_s {
8962 format: Format::ZSTD_f_zstd1,
8963 cParams: ZSTD_compressionParameters {
8964 windowLog: 0,
8965 chainLog: 0,
8966 hashLog: 0,
8967 searchLog: 0,
8968 minMatch: 0,
8969 targetLength: 0,
8970 strategy: 0,
8971 },
8972 fParams: ZSTD_frameParameters {
8973 contentSizeFlag: 0,
8974 checksumFlag: 0,
8975 noDictIDFlag: 0,
8976 },
8977 compressionLevel: 0,
8978 forceWindow: 0,
8979 targetCBlockSize: 0,
8980 srcSizeHint: 0,
8981 attachDictPref: ZSTD_dictDefaultAttach,
8982 literalCompressionMode: ZSTD_ps_auto,
8983 nbWorkers: 0,
8984 jobSize: 0,
8985 overlapLog: 0,
8986 rsyncable: 0,
8987 ldmParams: ldmParams_t {
8988 enableLdm: ZSTD_ps_auto,
8989 hashLog: 0,
8990 bucketSizeLog: 0,
8991 minMatchLength: 0,
8992 hashRateLog: 0,
8993 windowLog: 0,
8994 },
8995 enableDedicatedDictSearch: 0,
8996 inBufferMode: ZSTD_bm_buffered,
8997 outBufferMode: ZSTD_bm_buffered,
8998 blockDelimiters: ZSTD_sf_noBlockDelimiters,
8999 validateSequences: 0,
9000 postBlockSplitter: ZSTD_ps_auto,
9001 preBlockSplitter_level: 0,
9002 maxBlockSize: 0,
9003 useRowMatchFinder: ZSTD_ps_auto,
9004 deterministicRefPrefix: 0,
9005 customMem: ZSTD_customMem {
9006 customAlloc: None,
9007 customFree: None,
9008 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
9009 },
9010 prefetchCDictTables: ZSTD_ps_auto,
9011 enableMatchFinderFallback: 0,
9012 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
9013 extSeqProdFunc: None,
9014 searchForExternalRepcodes: ZSTD_ps_auto,
9015 };
9016 ptr::write_bytes(
9017 &mut cctxParams as *mut ZSTD_CCtx_params as *mut u8,
9018 0,
9019 ::core::mem::size_of::<ZSTD_CCtx_params>(),
9020 );
9021 ZSTD_CCtxParams_init(&mut cctxParams, 0);
9022 cctxParams.cParams = cParams;
9023 cctxParams.customMem = customMem;
9024 ZSTD_createCDict_advanced2(
9025 dictBuffer,
9026 dictSize,
9027 dictLoadMethod,
9028 dictContentType,
9029 &cctxParams,
9030 customMem,
9031 )
9032}
9033#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCDict_advanced2))]
9034pub unsafe extern "C" fn ZSTD_createCDict_advanced2(
9035 dict: *const core::ffi::c_void,
9036 dictSize: size_t,
9037 dictLoadMethod: ZSTD_dictLoadMethod_e,
9038 dictContentType: ZSTD_dictContentType_e,
9039 originalCctxParams: *const ZSTD_CCtx_params,
9040 customMem: ZSTD_customMem,
9041) -> *mut ZSTD_CDict {
9042 let mut cctxParams = *originalCctxParams;
9043 let mut cParams = ZSTD_compressionParameters {
9044 windowLog: 0,
9045 chainLog: 0,
9046 hashLog: 0,
9047 searchLog: 0,
9048 minMatch: 0,
9049 targetLength: 0,
9050 strategy: 0,
9051 };
9052 let mut cdict = core::ptr::null_mut::<ZSTD_CDict>();
9053 if (customMem.customAlloc).is_none() as core::ffi::c_int
9054 ^ (customMem.customFree).is_none() as core::ffi::c_int
9055 != 0
9056 {
9057 return core::ptr::null_mut();
9058 }
9059 if cctxParams.enableDedicatedDictSearch != 0 {
9060 cParams = ZSTD_dedicatedDictSearch_getCParams(cctxParams.compressionLevel, dictSize);
9061 ZSTD_overrideCParams(&mut cParams, &cctxParams.cParams);
9062 } else {
9063 cParams = ZSTD_getCParamsFromCCtxParams(
9064 &cctxParams,
9065 ZSTD_CONTENTSIZE_UNKNOWN,
9066 dictSize,
9067 ZSTD_cpm_createCDict,
9068 );
9069 }
9070 if ZSTD_dedicatedDictSearch_isSupported(&cParams) == 0 {
9071 cctxParams.enableDedicatedDictSearch = 0;
9072 cParams = ZSTD_getCParamsFromCCtxParams(
9073 &cctxParams,
9074 ZSTD_CONTENTSIZE_UNKNOWN,
9075 dictSize,
9076 ZSTD_cpm_createCDict,
9077 );
9078 }
9079 cctxParams.cParams = cParams;
9080 cctxParams.useRowMatchFinder =
9081 ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);
9082 cdict = ZSTD_createCDict_advanced_internal(
9083 dictSize,
9084 dictLoadMethod,
9085 cctxParams.cParams,
9086 cctxParams.useRowMatchFinder,
9087 cctxParams.enableDedicatedDictSearch,
9088 customMem,
9089 );
9090 if cdict.is_null()
9091 || ERR_isError(ZSTD_initCDict_internal(
9092 cdict,
9093 dict,
9094 dictSize,
9095 dictLoadMethod,
9096 dictContentType,
9097 cctxParams,
9098 ))
9099 {
9100 ZSTD_freeCDict(cdict);
9101 return core::ptr::null_mut();
9102 }
9103 cdict
9104}
9105#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCDict))]
9106pub unsafe extern "C" fn ZSTD_createCDict(
9107 dict: *const core::ffi::c_void,
9108 dictSize: size_t,
9109 compressionLevel: core::ffi::c_int,
9110) -> *mut ZSTD_CDict {
9111 let cParams = ZSTD_getCParams_internal(
9112 compressionLevel,
9113 ZSTD_CONTENTSIZE_UNKNOWN,
9114 dictSize,
9115 ZSTD_cpm_createCDict,
9116 );
9117 let cdict = ZSTD_createCDict_advanced(
9118 dict,
9119 dictSize,
9120 ZSTD_dlm_byCopy,
9121 ZSTD_dct_auto,
9122 cParams,
9123 ZSTD_defaultCMem,
9124 );
9125 if !cdict.is_null() {
9126 (*cdict).compressionLevel = if compressionLevel == 0 {
9127 ZSTD_CLEVEL_DEFAULT
9128 } else {
9129 compressionLevel
9130 };
9131 }
9132 cdict
9133}
9134#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCDict_byReference))]
9135pub unsafe extern "C" fn ZSTD_createCDict_byReference(
9136 dict: *const core::ffi::c_void,
9137 dictSize: size_t,
9138 compressionLevel: core::ffi::c_int,
9139) -> *mut ZSTD_CDict {
9140 let cParams = ZSTD_getCParams_internal(
9141 compressionLevel,
9142 ZSTD_CONTENTSIZE_UNKNOWN,
9143 dictSize,
9144 ZSTD_cpm_createCDict,
9145 );
9146 let cdict = ZSTD_createCDict_advanced(
9147 dict,
9148 dictSize,
9149 ZSTD_dlm_byRef,
9150 ZSTD_dct_auto,
9151 cParams,
9152 ZSTD_defaultCMem,
9153 );
9154 if !cdict.is_null() {
9155 (*cdict).compressionLevel = if compressionLevel == 0 {
9156 ZSTD_CLEVEL_DEFAULT
9157 } else {
9158 compressionLevel
9159 };
9160 }
9161 cdict
9162}
9163#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_freeCDict))]
9164pub unsafe extern "C" fn ZSTD_freeCDict(cdict: *mut ZSTD_CDict) -> size_t {
9165 if cdict.is_null() {
9166 return 0;
9167 }
9168 let cMem = (*cdict).customMem;
9169 let cdictInWorkspace =
9170 ZSTD_cwksp_owns_buffer(&(*cdict).workspace, cdict as *const core::ffi::c_void);
9171 ZSTD_cwksp_free(&mut (*cdict).workspace, cMem);
9172 if cdictInWorkspace == 0 {
9173 ZSTD_customFree(cdict as *mut core::ffi::c_void, cMem);
9174 }
9175 0
9176}
9177#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initStaticCDict))]
9178pub unsafe extern "C" fn ZSTD_initStaticCDict(
9179 workspace: *mut core::ffi::c_void,
9180 workspaceSize: size_t,
9181 dict: *const core::ffi::c_void,
9182 dictSize: size_t,
9183 dictLoadMethod: ZSTD_dictLoadMethod_e,
9184 dictContentType: ZSTD_dictContentType_e,
9185 cParams: ZSTD_compressionParameters,
9186) -> *const ZSTD_CDict {
9187 let useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams);
9188 let matchStateSize = ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, 1, 0);
9189 let neededSize = (ZSTD_cwksp_alloc_size(::core::mem::size_of::<ZSTD_CDict>()))
9190 .wrapping_add(
9191 if dictLoadMethod as core::ffi::c_uint
9192 == ZSTD_dlm_byRef as core::ffi::c_int as core::ffi::c_uint
9193 {
9194 0
9195 } else {
9196 ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(
9197 dictSize,
9198 ::core::mem::size_of::<*mut core::ffi::c_void>(),
9199 ))
9200 },
9201 )
9202 .wrapping_add(ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE as size_t))
9203 .wrapping_add(matchStateSize);
9204 let mut cdict = core::ptr::null_mut::<ZSTD_CDict>();
9205 let mut params = ZSTD_CCtx_params_s {
9206 format: Format::ZSTD_f_zstd1,
9207 cParams: ZSTD_compressionParameters {
9208 windowLog: 0,
9209 chainLog: 0,
9210 hashLog: 0,
9211 searchLog: 0,
9212 minMatch: 0,
9213 targetLength: 0,
9214 strategy: 0,
9215 },
9216 fParams: ZSTD_frameParameters {
9217 contentSizeFlag: 0,
9218 checksumFlag: 0,
9219 noDictIDFlag: 0,
9220 },
9221 compressionLevel: 0,
9222 forceWindow: 0,
9223 targetCBlockSize: 0,
9224 srcSizeHint: 0,
9225 attachDictPref: ZSTD_dictDefaultAttach,
9226 literalCompressionMode: ZSTD_ps_auto,
9227 nbWorkers: 0,
9228 jobSize: 0,
9229 overlapLog: 0,
9230 rsyncable: 0,
9231 ldmParams: ldmParams_t {
9232 enableLdm: ZSTD_ps_auto,
9233 hashLog: 0,
9234 bucketSizeLog: 0,
9235 minMatchLength: 0,
9236 hashRateLog: 0,
9237 windowLog: 0,
9238 },
9239 enableDedicatedDictSearch: 0,
9240 inBufferMode: ZSTD_bm_buffered,
9241 outBufferMode: ZSTD_bm_buffered,
9242 blockDelimiters: ZSTD_sf_noBlockDelimiters,
9243 validateSequences: 0,
9244 postBlockSplitter: ZSTD_ps_auto,
9245 preBlockSplitter_level: 0,
9246 maxBlockSize: 0,
9247 useRowMatchFinder: ZSTD_ps_auto,
9248 deterministicRefPrefix: 0,
9249 customMem: ZSTD_customMem {
9250 customAlloc: None,
9251 customFree: None,
9252 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
9253 },
9254 prefetchCDictTables: ZSTD_ps_auto,
9255 enableMatchFinderFallback: 0,
9256 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
9257 extSeqProdFunc: None,
9258 searchForExternalRepcodes: ZSTD_ps_auto,
9259 };
9260 if workspace as size_t & 7 != 0 {
9261 return core::ptr::null();
9262 }
9263 let mut ws = ZSTD_cwksp {
9264 workspace: core::ptr::null_mut::<core::ffi::c_void>(),
9265 workspaceEnd: core::ptr::null_mut::<core::ffi::c_void>(),
9266 objectEnd: core::ptr::null_mut::<core::ffi::c_void>(),
9267 tableEnd: core::ptr::null_mut::<core::ffi::c_void>(),
9268 tableValidEnd: core::ptr::null_mut::<core::ffi::c_void>(),
9269 allocStart: core::ptr::null_mut::<core::ffi::c_void>(),
9270 initOnceStart: core::ptr::null_mut::<core::ffi::c_void>(),
9271 allocFailed: 0,
9272 workspaceOversizedDuration: 0,
9273 phase: ZSTD_cwksp_alloc_objects,
9274 isStatic: ZSTD_cwksp_dynamic_alloc,
9275 };
9276 ZSTD_cwksp_init(&mut ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc);
9277 cdict =
9278 ZSTD_cwksp_reserve_object(&mut ws, ::core::mem::size_of::<ZSTD_CDict>()) as *mut ZSTD_CDict;
9279 if cdict.is_null() {
9280 return core::ptr::null();
9281 }
9282 ZSTD_cwksp_move(&mut (*cdict).workspace, &mut ws);
9283 if workspaceSize < neededSize {
9284 return core::ptr::null();
9285 }
9286 ZSTD_CCtxParams_init(&mut params, 0);
9287 params.cParams = cParams;
9288 params.useRowMatchFinder = useRowMatchFinder;
9289 (*cdict).useRowMatchFinder = useRowMatchFinder;
9290 (*cdict).compressionLevel = ZSTD_NO_CLEVEL;
9291 if ERR_isError(ZSTD_initCDict_internal(
9292 cdict,
9293 dict,
9294 dictSize,
9295 dictLoadMethod,
9296 dictContentType,
9297 params,
9298 )) {
9299 return core::ptr::null();
9300 }
9301 cdict
9302}
9303#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_getCParamsFromCDict))]
9304pub unsafe extern "C" fn ZSTD_getCParamsFromCDict(
9305 cdict: *const ZSTD_CDict,
9306) -> ZSTD_compressionParameters {
9307 (*cdict).matchState.cParams
9308}
9309#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_getDictID_fromCDict))]
9310pub unsafe extern "C" fn ZSTD_getDictID_fromCDict(cdict: *const ZSTD_CDict) -> core::ffi::c_uint {
9311 if cdict.is_null() {
9312 return 0;
9313 }
9314 (*cdict).dictID
9315}
9316unsafe fn ZSTD_compressBegin_usingCDict_internal(
9317 cctx: *mut ZSTD_CCtx,
9318 cdict: *const ZSTD_CDict,
9319 fParams: ZSTD_frameParameters,
9320 pledgedSrcSize: core::ffi::c_ulonglong,
9321) -> size_t {
9322 let mut cctxParams = ZSTD_CCtx_params_s {
9323 format: Format::ZSTD_f_zstd1,
9324 cParams: ZSTD_compressionParameters {
9325 windowLog: 0,
9326 chainLog: 0,
9327 hashLog: 0,
9328 searchLog: 0,
9329 minMatch: 0,
9330 targetLength: 0,
9331 strategy: 0,
9332 },
9333 fParams: ZSTD_frameParameters {
9334 contentSizeFlag: 0,
9335 checksumFlag: 0,
9336 noDictIDFlag: 0,
9337 },
9338 compressionLevel: 0,
9339 forceWindow: 0,
9340 targetCBlockSize: 0,
9341 srcSizeHint: 0,
9342 attachDictPref: ZSTD_dictDefaultAttach,
9343 literalCompressionMode: ZSTD_ps_auto,
9344 nbWorkers: 0,
9345 jobSize: 0,
9346 overlapLog: 0,
9347 rsyncable: 0,
9348 ldmParams: ldmParams_t {
9349 enableLdm: ZSTD_ps_auto,
9350 hashLog: 0,
9351 bucketSizeLog: 0,
9352 minMatchLength: 0,
9353 hashRateLog: 0,
9354 windowLog: 0,
9355 },
9356 enableDedicatedDictSearch: 0,
9357 inBufferMode: ZSTD_bm_buffered,
9358 outBufferMode: ZSTD_bm_buffered,
9359 blockDelimiters: ZSTD_sf_noBlockDelimiters,
9360 validateSequences: 0,
9361 postBlockSplitter: ZSTD_ps_auto,
9362 preBlockSplitter_level: 0,
9363 maxBlockSize: 0,
9364 useRowMatchFinder: ZSTD_ps_auto,
9365 deterministicRefPrefix: 0,
9366 customMem: ZSTD_customMem {
9367 customAlloc: None,
9368 customFree: None,
9369 opaque: core::ptr::null_mut::<core::ffi::c_void>(),
9370 },
9371 prefetchCDictTables: ZSTD_ps_auto,
9372 enableMatchFinderFallback: 0,
9373 extSeqProdState: core::ptr::null_mut::<core::ffi::c_void>(),
9374 extSeqProdFunc: None,
9375 searchForExternalRepcodes: ZSTD_ps_auto,
9376 };
9377 if cdict.is_null() {
9378 return Error::dictionary_wrong.to_error_code();
9379 }
9380 let mut params = ZSTD_parameters {
9381 cParams: ZSTD_compressionParameters {
9382 windowLog: 0,
9383 chainLog: 0,
9384 hashLog: 0,
9385 searchLog: 0,
9386 minMatch: 0,
9387 targetLength: 0,
9388 strategy: 0,
9389 },
9390 fParams: ZSTD_frameParameters {
9391 contentSizeFlag: 0,
9392 checksumFlag: 0,
9393 noDictIDFlag: 0,
9394 },
9395 };
9396 params.fParams = fParams;
9397 params.cParams = if pledgedSrcSize
9398 < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF as core::ffi::c_ulonglong
9399 || pledgedSrcSize
9400 < ((*cdict).dictContentSize as core::ffi::c_ulonglong)
9401 .wrapping_mul(ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER)
9402 || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
9403 || (*cdict).compressionLevel == 0
9404 {
9405 ZSTD_getCParamsFromCDict(cdict)
9406 } else {
9407 ZSTD_getCParams(
9408 (*cdict).compressionLevel,
9409 pledgedSrcSize,
9410 (*cdict).dictContentSize,
9411 )
9412 };
9413 ZSTD_CCtxParams_init_internal(&mut cctxParams, ¶ms, (*cdict).compressionLevel);
9414 if pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN {
9415 let limitedSrcSize = (if pledgedSrcSize < ((1) << 19) as core::ffi::c_ulonglong {
9416 pledgedSrcSize
9417 } else {
9418 ((1) << 19) as core::ffi::c_ulonglong
9419 }) as u32;
9420 let limitedSrcLog = if limitedSrcSize > 1 {
9421 (ZSTD_highbit32(limitedSrcSize.wrapping_sub(1))).wrapping_add(1)
9422 } else {
9423 1
9424 };
9425 cctxParams.cParams.windowLog = if cctxParams.cParams.windowLog > limitedSrcLog {
9426 cctxParams.cParams.windowLog
9427 } else {
9428 limitedSrcLog
9429 };
9430 }
9431 ZSTD_compressBegin_internal(
9432 cctx,
9433 core::ptr::null(),
9434 0,
9435 ZSTD_dct_auto,
9436 ZSTD_dtlm_fast,
9437 cdict,
9438 &cctxParams,
9439 pledgedSrcSize,
9440 ZSTDb_not_buffered,
9441 )
9442}
9443#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBegin_usingCDict_advanced))]
9444pub unsafe extern "C" fn ZSTD_compressBegin_usingCDict_advanced(
9445 cctx: *mut ZSTD_CCtx,
9446 cdict: *const ZSTD_CDict,
9447 fParams: ZSTD_frameParameters,
9448 pledgedSrcSize: core::ffi::c_ulonglong,
9449) -> size_t {
9450 ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, pledgedSrcSize)
9451}
9452#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBegin_usingCDict_deprecated))]
9453pub unsafe extern "C" fn ZSTD_compressBegin_usingCDict_deprecated(
9454 cctx: *mut ZSTD_CCtx,
9455 cdict: *const ZSTD_CDict,
9456) -> size_t {
9457 let fParams = {
9458 ZSTD_frameParameters {
9459 contentSizeFlag: 0,
9460 checksumFlag: 0,
9461 noDictIDFlag: 0,
9462 }
9463 };
9464 ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN)
9465}
9466#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressBegin_usingCDict))]
9467pub unsafe extern "C" fn ZSTD_compressBegin_usingCDict(
9468 cctx: *mut ZSTD_CCtx,
9469 cdict: *const ZSTD_CDict,
9470) -> size_t {
9471 ZSTD_compressBegin_usingCDict_deprecated(cctx, cdict)
9472}
9473unsafe fn ZSTD_compress_usingCDict_internal(
9474 cctx: *mut ZSTD_CCtx,
9475 dst: *mut core::ffi::c_void,
9476 dstCapacity: size_t,
9477 src: *const core::ffi::c_void,
9478 srcSize: size_t,
9479 cdict: *const ZSTD_CDict,
9480 fParams: ZSTD_frameParameters,
9481) -> size_t {
9482 let err_code = ZSTD_compressBegin_usingCDict_internal(
9483 cctx,
9484 cdict,
9485 fParams,
9486 srcSize as core::ffi::c_ulonglong,
9487 );
9488 if ERR_isError(err_code) {
9489 return err_code;
9490 }
9491 ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize)
9492}
9493#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compress_usingCDict_advanced))]
9494pub unsafe extern "C" fn ZSTD_compress_usingCDict_advanced(
9495 cctx: *mut ZSTD_CCtx,
9496 dst: *mut core::ffi::c_void,
9497 dstCapacity: size_t,
9498 src: *const core::ffi::c_void,
9499 srcSize: size_t,
9500 cdict: *const ZSTD_CDict,
9501 fParams: ZSTD_frameParameters,
9502) -> size_t {
9503 ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams)
9504}
9505#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compress_usingCDict))]
9506pub unsafe extern "C" fn ZSTD_compress_usingCDict(
9507 cctx: *mut ZSTD_CCtx,
9508 dst: *mut core::ffi::c_void,
9509 dstCapacity: size_t,
9510 src: *const core::ffi::c_void,
9511 srcSize: size_t,
9512 cdict: *const ZSTD_CDict,
9513) -> size_t {
9514 let fParams = {
9515 ZSTD_frameParameters {
9516 contentSizeFlag: 1,
9517 checksumFlag: 0,
9518 noDictIDFlag: 0,
9519 }
9520 };
9521 ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams)
9522}
9523#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCStream))]
9524pub unsafe extern "C" fn ZSTD_createCStream() -> *mut ZSTD_CStream {
9525 ZSTD_createCStream_advanced(ZSTD_defaultCMem)
9526}
9527#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initStaticCStream))]
9528pub unsafe extern "C" fn ZSTD_initStaticCStream(
9529 workspace: *mut core::ffi::c_void,
9530 workspaceSize: size_t,
9531) -> *mut ZSTD_CStream {
9532 ZSTD_initStaticCCtx(workspace, workspaceSize)
9533}
9534#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_createCStream_advanced))]
9535pub unsafe extern "C" fn ZSTD_createCStream_advanced(
9536 customMem: ZSTD_customMem,
9537) -> *mut ZSTD_CStream {
9538 ZSTD_createCCtx_advanced(customMem)
9539}
9540#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_freeCStream))]
9541pub unsafe extern "C" fn ZSTD_freeCStream(zcs: *mut ZSTD_CStream) -> size_t {
9542 ZSTD_freeCCtx(zcs)
9543}
9544#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CStreamInSize))]
9545pub unsafe extern "C" fn ZSTD_CStreamInSize() -> size_t {
9546 ZSTD_BLOCKSIZE_MAX as size_t
9547}
9548#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CStreamOutSize))]
9549pub unsafe extern "C" fn ZSTD_CStreamOutSize() -> size_t {
9550 (ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX as size_t))
9551 .wrapping_add(ZSTD_blockHeaderSize)
9552 .wrapping_add(4)
9553}
9554unsafe fn ZSTD_getCParamMode(
9555 cdict: *const ZSTD_CDict,
9556 params: *const ZSTD_CCtx_params,
9557 pledgedSrcSize: u64,
9558) -> ZSTD_CParamMode_e {
9559 if !cdict.is_null() && ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize) != 0 {
9560 ZSTD_cpm_attachDict
9561 } else {
9562 ZSTD_cpm_noAttachDict
9563 }
9564}
9565#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_resetCStream))]
9566pub unsafe extern "C" fn ZSTD_resetCStream(
9567 zcs: *mut ZSTD_CStream,
9568 pss: core::ffi::c_ulonglong,
9569) -> size_t {
9570 let pledgedSrcSize = if pss == 0 {
9571 ZSTD_CONTENTSIZE_UNKNOWN
9572 } else {
9573 pss
9574 };
9575 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9576 if ERR_isError(err_code) {
9577 return err_code;
9578 }
9579 let err_code_0 = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize as core::ffi::c_ulonglong);
9580 if ERR_isError(err_code_0) {
9581 return err_code_0;
9582 }
9583 0
9584}
9585pub unsafe fn ZSTD_initCStream_internal(
9586 zcs: *mut ZSTD_CStream,
9587 dict: *const core::ffi::c_void,
9588 dictSize: size_t,
9589 cdict: *const ZSTD_CDict,
9590 params: *const ZSTD_CCtx_params,
9591 pledgedSrcSize: core::ffi::c_ulonglong,
9592) -> size_t {
9593 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9594 if ERR_isError(err_code) {
9595 return err_code;
9596 }
9597 let err_code_0 = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
9598 if ERR_isError(err_code_0) {
9599 return err_code_0;
9600 }
9601 (*zcs).requestedParams = *params;
9602 if !dict.is_null() {
9603 let err_code_1 = ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
9604 if ERR_isError(err_code_1) {
9605 return err_code_1;
9606 }
9607 } else {
9608 let err_code_2 = ZSTD_CCtx_refCDict(zcs, cdict);
9609 if ERR_isError(err_code_2) {
9610 return err_code_2;
9611 }
9612 }
9613 0
9614}
9615#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initCStream_usingCDict_advanced))]
9616pub unsafe extern "C" fn ZSTD_initCStream_usingCDict_advanced(
9617 zcs: *mut ZSTD_CStream,
9618 cdict: *const ZSTD_CDict,
9619 fParams: ZSTD_frameParameters,
9620 pledgedSrcSize: core::ffi::c_ulonglong,
9621) -> size_t {
9622 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9623 if ERR_isError(err_code) {
9624 return err_code;
9625 }
9626 let err_code_0 = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
9627 if ERR_isError(err_code_0) {
9628 return err_code_0;
9629 }
9630 (*zcs).requestedParams.fParams = fParams;
9631 let err_code_1 = ZSTD_CCtx_refCDict(zcs, cdict);
9632 if ERR_isError(err_code_1) {
9633 return err_code_1;
9634 }
9635 0
9636}
9637#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initCStream_usingCDict))]
9638pub unsafe extern "C" fn ZSTD_initCStream_usingCDict(
9639 zcs: *mut ZSTD_CStream,
9640 cdict: *const ZSTD_CDict,
9641) -> size_t {
9642 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9643 if ERR_isError(err_code) {
9644 return err_code;
9645 }
9646 let err_code_0 = ZSTD_CCtx_refCDict(zcs, cdict);
9647 if ERR_isError(err_code_0) {
9648 return err_code_0;
9649 }
9650 0
9651}
9652#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initCStream_advanced))]
9653pub unsafe extern "C" fn ZSTD_initCStream_advanced(
9654 zcs: *mut ZSTD_CStream,
9655 dict: *const core::ffi::c_void,
9656 dictSize: size_t,
9657 params: ZSTD_parameters,
9658 pss: core::ffi::c_ulonglong,
9659) -> size_t {
9660 let pledgedSrcSize = if pss == 0 && params.fParams.contentSizeFlag == 0 {
9661 ZSTD_CONTENTSIZE_UNKNOWN
9662 } else {
9663 pss
9664 };
9665 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9666 if ERR_isError(err_code) {
9667 return err_code;
9668 }
9669 let err_code_0 = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize as core::ffi::c_ulonglong);
9670 if ERR_isError(err_code_0) {
9671 return err_code_0;
9672 }
9673 let err_code_1 = ZSTD_checkCParams(params.cParams);
9674 if ERR_isError(err_code_1) {
9675 return err_code_1;
9676 }
9677 ZSTD_CCtxParams_setZstdParams(&mut (*zcs).requestedParams, ¶ms);
9678 let err_code_2 = ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
9679 if ERR_isError(err_code_2) {
9680 return err_code_2;
9681 }
9682 0
9683}
9684#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initCStream_usingDict))]
9685pub unsafe extern "C" fn ZSTD_initCStream_usingDict(
9686 zcs: *mut ZSTD_CStream,
9687 dict: *const core::ffi::c_void,
9688 dictSize: size_t,
9689 compressionLevel: core::ffi::c_int,
9690) -> size_t {
9691 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9692 if ERR_isError(err_code) {
9693 return err_code;
9694 }
9695 let err_code_0 = ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
9696 if ERR_isError(err_code_0) {
9697 return err_code_0;
9698 }
9699 let err_code_1 = ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
9700 if ERR_isError(err_code_1) {
9701 return err_code_1;
9702 }
9703 0
9704}
9705#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initCStream_srcSize))]
9706pub unsafe extern "C" fn ZSTD_initCStream_srcSize(
9707 zcs: *mut ZSTD_CStream,
9708 compressionLevel: core::ffi::c_int,
9709 pss: core::ffi::c_ulonglong,
9710) -> size_t {
9711 let pledgedSrcSize = if pss == 0 {
9712 ZSTD_CONTENTSIZE_UNKNOWN
9713 } else {
9714 pss
9715 };
9716 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9717 if ERR_isError(err_code) {
9718 return err_code;
9719 }
9720 let err_code_0 = ZSTD_CCtx_refCDict(zcs, core::ptr::null::<ZSTD_CDict>());
9721 if ERR_isError(err_code_0) {
9722 return err_code_0;
9723 }
9724 let err_code_1 = ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
9725 if ERR_isError(err_code_1) {
9726 return err_code_1;
9727 }
9728 let err_code_2 = ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize as core::ffi::c_ulonglong);
9729 if ERR_isError(err_code_2) {
9730 return err_code_2;
9731 }
9732 0
9733}
9734#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initCStream))]
9735pub unsafe extern "C" fn ZSTD_initCStream(
9736 zcs: *mut ZSTD_CStream,
9737 compressionLevel: core::ffi::c_int,
9738) -> size_t {
9739 let err_code = ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9740 if ERR_isError(err_code) {
9741 return err_code;
9742 }
9743 let err_code_0 = ZSTD_CCtx_refCDict(zcs, core::ptr::null::<ZSTD_CDict>());
9744 if ERR_isError(err_code_0) {
9745 return err_code_0;
9746 }
9747 let err_code_1 = ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);
9748 if ERR_isError(err_code_1) {
9749 return err_code_1;
9750 }
9751 0
9752}
9753unsafe fn ZSTD_nextInputSizeHint(cctx: *const ZSTD_CCtx) -> size_t {
9754 if (*cctx).appliedParams.inBufferMode as core::ffi::c_uint
9755 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
9756 {
9757 return ((*cctx).blockSizeMax).wrapping_sub((*cctx).stableIn_notConsumed);
9758 }
9759 let mut hintInSize = ((*cctx).inBuffTarget).wrapping_sub((*cctx).inBuffPos);
9760 if hintInSize == 0 {
9761 hintInSize = (*cctx).blockSizeMax;
9762 }
9763 hintInSize
9764}
9765unsafe fn ZSTD_compressStream_generic(
9766 zcs: *mut ZSTD_CStream,
9767 output: *mut ZSTD_outBuffer,
9768 input: *mut ZSTD_inBuffer,
9769 flushMode: ZSTD_EndDirective,
9770) -> size_t {
9771 let istart = (*input).src as *const core::ffi::c_char;
9772 let iend = if !istart.is_null() {
9773 istart.add((*input).size)
9774 } else {
9775 istart
9776 };
9777 let mut ip = if !istart.is_null() {
9778 istart.add((*input).pos)
9779 } else {
9780 istart
9781 };
9782 let ostart = (*output).dst as *mut core::ffi::c_char;
9783 let oend = if !ostart.is_null() {
9784 ostart.add((*output).size)
9785 } else {
9786 ostart
9787 };
9788 let mut op = if !ostart.is_null() {
9789 ostart.add((*output).pos)
9790 } else {
9791 ostart
9792 };
9793 let mut someMoreWork = 1;
9794 if (*zcs).appliedParams.inBufferMode as core::ffi::c_uint
9795 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
9796 {
9797 (*input).pos = ((*input).pos).wrapping_sub((*zcs).stableIn_notConsumed);
9798 if !ip.is_null() {
9799 ip = ip.offset(-((*zcs).stableIn_notConsumed as isize));
9800 }
9801 (*zcs).stableIn_notConsumed = 0;
9802 }
9803 (*zcs).appliedParams.inBufferMode as core::ffi::c_uint
9804 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint;
9805 (*zcs).appliedParams.outBufferMode as core::ffi::c_uint
9806 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint;
9807 ((*input).src).is_null();
9808 ((*output).dst).is_null();
9809 while someMoreWork != 0 {
9810 let mut current_block_156: u64;
9811 match (*zcs).streamStage as core::ffi::c_uint {
9812 0 => return Error::init_missing.to_error_code(),
9813 1 => {
9814 if flushMode as core::ffi::c_uint
9815 == ZSTD_e_end as core::ffi::c_int as core::ffi::c_uint
9816 && (oend.offset_from(op) as size_t
9817 >= ZSTD_compressBound(iend.offset_from(ip) as size_t)
9818 || (*zcs).appliedParams.outBufferMode as core::ffi::c_uint
9819 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint)
9820 && (*zcs).inBuffPos == 0
9821 {
9822 let cSize = ZSTD_compressEnd_public(
9823 zcs,
9824 op as *mut core::ffi::c_void,
9825 oend.offset_from(op) as size_t,
9826 ip as *const core::ffi::c_void,
9827 iend.offset_from(ip) as size_t,
9828 );
9829 let err_code = cSize;
9830 if ERR_isError(err_code) {
9831 return err_code;
9832 }
9833 ip = iend;
9834 op = op.add(cSize);
9835 (*zcs).frameEnded = 1;
9836 ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9837 someMoreWork = 0;
9838 current_block_156 = 16754622181974910496;
9839 } else {
9840 if (*zcs).appliedParams.inBufferMode as core::ffi::c_uint
9841 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint
9842 {
9843 let toLoad = ((*zcs).inBuffTarget).wrapping_sub((*zcs).inBuffPos);
9844 let loaded = ZSTD_limitCopy(
9845 ((*zcs).inBuff).add((*zcs).inBuffPos) as *mut core::ffi::c_void,
9846 toLoad,
9847 ip as *const core::ffi::c_void,
9848 iend.offset_from(ip) as size_t,
9849 );
9850 (*zcs).inBuffPos = ((*zcs).inBuffPos).wrapping_add(loaded);
9851 if !ip.is_null() {
9852 ip = ip.add(loaded);
9853 }
9854 if flushMode as core::ffi::c_uint
9855 == ZSTD_e_continue as core::ffi::c_int as core::ffi::c_uint
9856 && (*zcs).inBuffPos < (*zcs).inBuffTarget
9857 {
9858 someMoreWork = 0;
9859 current_block_156 = 16754622181974910496;
9860 } else if flushMode as core::ffi::c_uint
9861 == ZSTD_e_flush as core::ffi::c_int as core::ffi::c_uint
9862 && (*zcs).inBuffPos == (*zcs).inToCompress
9863 {
9864 someMoreWork = 0;
9865 current_block_156 = 16754622181974910496;
9866 } else {
9867 current_block_156 = 13910774313357589740;
9868 }
9869 } else if flushMode as core::ffi::c_uint
9870 == ZSTD_e_continue as core::ffi::c_int as core::ffi::c_uint
9871 && (iend.offset_from(ip) as size_t) < (*zcs).blockSizeMax
9872 {
9873 (*zcs).stableIn_notConsumed = iend.offset_from(ip) as size_t;
9874 ip = iend;
9875 someMoreWork = 0;
9876 current_block_156 = 16754622181974910496;
9877 } else if flushMode as core::ffi::c_uint
9878 == ZSTD_e_flush as core::ffi::c_int as core::ffi::c_uint
9879 && ip == iend
9880 {
9881 someMoreWork = 0;
9882 current_block_156 = 16754622181974910496;
9883 } else {
9884 current_block_156 = 13910774313357589740;
9885 }
9886 match current_block_156 {
9887 16754622181974910496 => {}
9888 _ => {
9889 let inputBuffered = ((*zcs).appliedParams.inBufferMode
9890 as core::ffi::c_uint
9891 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint)
9892 as core::ffi::c_int;
9893 let mut cDst = core::ptr::null_mut::<core::ffi::c_void>();
9894 let mut cSize_0: size_t = 0;
9895 let mut oSize = oend.offset_from(op) as size_t;
9896 let iSize = if inputBuffered != 0 {
9897 ((*zcs).inBuffPos).wrapping_sub((*zcs).inToCompress)
9898 } else if (iend.offset_from(ip) as size_t) < (*zcs).blockSizeMax {
9899 iend.offset_from(ip) as size_t
9900 } else {
9901 (*zcs).blockSizeMax
9902 };
9903 if oSize >= ZSTD_compressBound(iSize)
9904 || (*zcs).appliedParams.outBufferMode as core::ffi::c_uint
9905 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
9906 {
9907 cDst = op as *mut core::ffi::c_void;
9908 } else {
9909 cDst = (*zcs).outBuff as *mut core::ffi::c_void;
9910 oSize = (*zcs).outBuffSize;
9911 }
9912 if inputBuffered != 0 {
9913 let lastBlock = (flushMode as core::ffi::c_uint
9914 == ZSTD_e_end as core::ffi::c_int as core::ffi::c_uint
9915 && ip == iend)
9916 as core::ffi::c_int
9917 as core::ffi::c_uint;
9918 cSize_0 = if lastBlock != 0 {
9919 ZSTD_compressEnd_public(
9920 zcs,
9921 cDst,
9922 oSize,
9923 ((*zcs).inBuff).add((*zcs).inToCompress)
9924 as *const core::ffi::c_void,
9925 iSize,
9926 )
9927 } else {
9928 ZSTD_compressContinue_public(
9929 zcs,
9930 cDst,
9931 oSize,
9932 ((*zcs).inBuff).add((*zcs).inToCompress)
9933 as *const core::ffi::c_void,
9934 iSize,
9935 )
9936 };
9937 let err_code_0 = cSize_0;
9938 if ERR_isError(err_code_0) {
9939 return err_code_0;
9940 }
9941 (*zcs).frameEnded = lastBlock;
9942 (*zcs).inBuffTarget =
9943 ((*zcs).inBuffPos).wrapping_add((*zcs).blockSizeMax);
9944 if (*zcs).inBuffTarget > (*zcs).inBuffSize {
9945 (*zcs).inBuffPos = 0;
9946 (*zcs).inBuffTarget = (*zcs).blockSizeMax;
9947 }
9948 lastBlock == 0;
9949 (*zcs).inToCompress = (*zcs).inBuffPos;
9950 } else {
9951 let lastBlock_0 = (flushMode as core::ffi::c_uint
9952 == ZSTD_e_end as core::ffi::c_int as core::ffi::c_uint
9953 && ip.add(iSize) == iend)
9954 as core::ffi::c_int
9955 as core::ffi::c_uint;
9956 cSize_0 = if lastBlock_0 != 0 {
9957 ZSTD_compressEnd_public(
9958 zcs,
9959 cDst,
9960 oSize,
9961 ip as *const core::ffi::c_void,
9962 iSize,
9963 )
9964 } else {
9965 ZSTD_compressContinue_public(
9966 zcs,
9967 cDst,
9968 oSize,
9969 ip as *const core::ffi::c_void,
9970 iSize,
9971 )
9972 };
9973 if !ip.is_null() {
9974 ip = ip.add(iSize);
9975 }
9976 let err_code_1 = cSize_0;
9977 if ERR_isError(err_code_1) {
9978 return err_code_1;
9979 }
9980 (*zcs).frameEnded = lastBlock_0;
9981 lastBlock_0 != 0;
9982 }
9983 if cDst == op as *mut core::ffi::c_void {
9984 op = op.add(cSize_0);
9985 if (*zcs).frameEnded != 0 {
9986 someMoreWork = 0;
9987 ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
9988 }
9989 current_block_156 = 16754622181974910496;
9990 } else {
9991 (*zcs).outBuffContentSize = cSize_0;
9992 (*zcs).outBuffFlushedSize = 0;
9993 (*zcs).streamStage = zcss_flush;
9994 current_block_156 = 5431927413890720344;
9995 }
9996 }
9997 }
9998 }
9999 }
10000 2 => {
10001 current_block_156 = 5431927413890720344;
10002 }
10003 _ => {
10004 current_block_156 = 16754622181974910496;
10005 }
10006 }
10007 if current_block_156 == 5431927413890720344 {
10008 let toFlush = ((*zcs).outBuffContentSize).wrapping_sub((*zcs).outBuffFlushedSize);
10009 let flushed = ZSTD_limitCopy(
10010 op as *mut core::ffi::c_void,
10011 oend.offset_from(op) as size_t,
10012 ((*zcs).outBuff).add((*zcs).outBuffFlushedSize) as *const core::ffi::c_void,
10013 toFlush,
10014 );
10015 if flushed != 0 {
10016 op = op.add(flushed);
10017 }
10018 (*zcs).outBuffFlushedSize = ((*zcs).outBuffFlushedSize).wrapping_add(flushed);
10019 if toFlush != flushed {
10020 someMoreWork = 0;
10021 } else {
10022 (*zcs).outBuffFlushedSize = 0;
10023 (*zcs).outBuffContentSize = (*zcs).outBuffFlushedSize;
10024 if (*zcs).frameEnded != 0 {
10025 someMoreWork = 0;
10026 ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
10027 } else {
10028 (*zcs).streamStage = zcss_load;
10029 }
10030 }
10031 }
10032 }
10033 (*input).pos = ip.offset_from(istart) as size_t;
10034 (*output).pos = op.offset_from(ostart) as size_t;
10035 if (*zcs).frameEnded != 0 {
10036 return 0;
10037 }
10038 ZSTD_nextInputSizeHint(zcs)
10039}
10040unsafe fn ZSTD_nextInputSizeHint_MTorST(cctx: *const ZSTD_CCtx) -> size_t {
10041 if (*cctx).appliedParams.nbWorkers >= 1 {
10042 return ZSTDMT_nextInputSizeHint((*cctx).mtctx);
10043 }
10044 ZSTD_nextInputSizeHint(cctx)
10045}
10046#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressStream))]
10047pub unsafe extern "C" fn ZSTD_compressStream(
10048 zcs: *mut ZSTD_CStream,
10049 output: *mut ZSTD_outBuffer,
10050 input: *mut ZSTD_inBuffer,
10051) -> size_t {
10052 let err_code = ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue);
10053 if ERR_isError(err_code) {
10054 return err_code;
10055 }
10056 ZSTD_nextInputSizeHint_MTorST(zcs)
10057}
10058unsafe fn ZSTD_setBufferExpectations(
10059 cctx: *mut ZSTD_CCtx,
10060 output: *const ZSTD_outBuffer,
10061 input: *const ZSTD_inBuffer,
10062) {
10063 if (*cctx).appliedParams.inBufferMode as core::ffi::c_uint
10064 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
10065 {
10066 (*cctx).expectedInBuffer = *input;
10067 }
10068 if (*cctx).appliedParams.outBufferMode as core::ffi::c_uint
10069 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
10070 {
10071 (*cctx).expectedOutBufferSize = ((*output).size).wrapping_sub((*output).pos);
10072 }
10073}
10074unsafe fn ZSTD_checkBufferStability(
10075 cctx: *const ZSTD_CCtx,
10076 output: *const ZSTD_outBuffer,
10077 input: *const ZSTD_inBuffer,
10078 endOp: ZSTD_EndDirective,
10079) -> size_t {
10080 if (*cctx).appliedParams.inBufferMode as core::ffi::c_uint
10081 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
10082 {
10083 let expect = (*cctx).expectedInBuffer;
10084 if expect.src != (*input).src || expect.pos != (*input).pos {
10085 return Error::stabilityCondition_notRespected.to_error_code();
10086 }
10087 }
10088 if (*cctx).appliedParams.outBufferMode as core::ffi::c_uint
10089 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
10090 {
10091 let outBufferSize = ((*output).size).wrapping_sub((*output).pos);
10092 if (*cctx).expectedOutBufferSize != outBufferSize {
10093 return Error::stabilityCondition_notRespected.to_error_code();
10094 }
10095 }
10096 0
10097}
10098unsafe fn ZSTD_CCtx_init_compressStream2(
10099 cctx: *mut ZSTD_CCtx,
10100 endOp: ZSTD_EndDirective,
10101 inSize: size_t,
10102) -> size_t {
10103 let mut params = (*cctx).requestedParams;
10104 let prefixDict = (*cctx).prefixDict;
10105 let err_code = ZSTD_initLocalDict(cctx);
10106 if ERR_isError(err_code) {
10107 return err_code;
10108 }
10109 ptr::write_bytes(
10110 &mut (*cctx).prefixDict as *mut ZSTD_prefixDict as *mut u8,
10111 0,
10112 ::core::mem::size_of::<ZSTD_prefixDict>(),
10113 );
10114 if !((*cctx).cdict).is_null() && ((*cctx).localDict.cdict).is_null() {
10115 params.compressionLevel = (*(*cctx).cdict).compressionLevel;
10116 }
10117 if endOp as core::ffi::c_uint == ZSTD_e_end as core::ffi::c_int as core::ffi::c_uint {
10118 (*cctx).pledgedSrcSizePlusOne = inSize.wrapping_add(1) as core::ffi::c_ulonglong;
10119 }
10120 let dictSize = if !(prefixDict.dict).is_null() {
10121 prefixDict.dictSize
10122 } else if !((*cctx).cdict).is_null() {
10123 (*(*cctx).cdict).dictContentSize
10124 } else {
10125 0
10126 };
10127 let mode = ZSTD_getCParamMode(
10128 (*cctx).cdict,
10129 ¶ms,
10130 ((*cctx).pledgedSrcSizePlusOne).wrapping_sub(1),
10131 );
10132 params.cParams = ZSTD_getCParamsFromCCtxParams(
10133 ¶ms,
10134 ((*cctx).pledgedSrcSizePlusOne).wrapping_sub(1),
10135 dictSize,
10136 mode,
10137 );
10138 params.postBlockSplitter =
10139 ZSTD_resolveBlockSplitterMode(params.postBlockSplitter, ¶ms.cParams);
10140 params.ldmParams.enableLdm = ZSTD_resolveEnableLdm(params.ldmParams.enableLdm, ¶ms.cParams);
10141 params.useRowMatchFinder =
10142 ZSTD_resolveRowMatchFinderMode(params.useRowMatchFinder, ¶ms.cParams);
10143 params.validateSequences = ZSTD_resolveExternalSequenceValidation(params.validateSequences);
10144 params.maxBlockSize = ZSTD_resolveMaxBlockSize(params.maxBlockSize);
10145 params.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(
10146 params.searchForExternalRepcodes,
10147 params.compressionLevel,
10148 );
10149 if ZSTD_hasExtSeqProd(¶ms) != 0 && params.nbWorkers >= 1 {
10150 return Error::parameter_combination_unsupported.to_error_code();
10151 }
10152 if ((*cctx).pledgedSrcSizePlusOne).wrapping_sub(1)
10153 <= ZSTDMT_JOBSIZE_MIN as core::ffi::c_ulonglong
10154 {
10155 params.nbWorkers = 0;
10156 }
10157 if params.nbWorkers > 0 {
10158 (*cctx).traceCtx = ZSTD_trace_compress_begin(cctx);
10159 if ((*cctx).mtctx).is_null() {
10160 (*cctx).mtctx = ZSTDMT_createCCtx_advanced(
10161 params.nbWorkers as u32,
10162 (*cctx).customMem,
10163 (*cctx).pool,
10164 );
10165 if ((*cctx).mtctx).is_null() {
10166 return Error::memory_allocation.to_error_code();
10167 }
10168 }
10169 let err_code_0 = ZSTDMT_initCStream_internal(
10170 (*cctx).mtctx,
10171 prefixDict.dict,
10172 prefixDict.dictSize,
10173 prefixDict.dictContentType,
10174 (*cctx).cdict,
10175 params,
10176 ((*cctx).pledgedSrcSizePlusOne).wrapping_sub(1),
10177 );
10178 if ERR_isError(err_code_0) {
10179 return err_code_0;
10180 }
10181 (*cctx).dictID = if !((*cctx).cdict).is_null() {
10182 (*(*cctx).cdict).dictID
10183 } else {
10184 0
10185 };
10186 (*cctx).dictContentSize = if !((*cctx).cdict).is_null() {
10187 (*(*cctx).cdict).dictContentSize
10188 } else {
10189 prefixDict.dictSize
10190 };
10191 (*cctx).consumedSrcSize = 0;
10192 (*cctx).producedCSize = 0;
10193 (*cctx).streamStage = zcss_load;
10194 (*cctx).appliedParams = params;
10195 } else {
10196 let pledgedSrcSize = ((*cctx).pledgedSrcSizePlusOne).wrapping_sub(1);
10197 let err_code_1 = ZSTD_compressBegin_internal(
10198 cctx,
10199 prefixDict.dict,
10200 prefixDict.dictSize,
10201 prefixDict.dictContentType,
10202 ZSTD_dtlm_fast,
10203 (*cctx).cdict,
10204 ¶ms,
10205 pledgedSrcSize,
10206 ZSTDb_buffered,
10207 );
10208 if ERR_isError(err_code_1) {
10209 return err_code_1;
10210 }
10211 (*cctx).inToCompress = 0;
10212 (*cctx).inBuffPos = 0;
10213 if (*cctx).appliedParams.inBufferMode as core::ffi::c_uint
10214 == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint
10215 {
10216 (*cctx).inBuffTarget = ((*cctx).blockSizeMax).wrapping_add(
10217 ((*cctx).blockSizeMax as u64 == pledgedSrcSize) as core::ffi::c_int as size_t,
10218 );
10219 } else {
10220 (*cctx).inBuffTarget = 0;
10221 }
10222 (*cctx).outBuffFlushedSize = 0;
10223 (*cctx).outBuffContentSize = (*cctx).outBuffFlushedSize;
10224 (*cctx).streamStage = zcss_load;
10225 (*cctx).frameEnded = 0;
10226 }
10227 0
10228}
10229#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressStream2))]
10230pub unsafe extern "C" fn ZSTD_compressStream2(
10231 cctx: *mut ZSTD_CCtx,
10232 output: *mut ZSTD_outBuffer,
10233 input: *mut ZSTD_inBuffer,
10234 endOp: ZSTD_EndDirective,
10235) -> size_t {
10236 if (*output).pos > (*output).size {
10237 return Error::dstSize_tooSmall.to_error_code();
10238 }
10239 if (*input).pos > (*input).size {
10240 return Error::srcSize_wrong.to_error_code();
10241 }
10242 if endOp > ZSTD_e_end as core::ffi::c_int as u32 {
10243 return Error::parameter_outOfBound.to_error_code();
10244 }
10245 if (*cctx).streamStage as core::ffi::c_uint
10246 == zcss_init as core::ffi::c_int as core::ffi::c_uint
10247 {
10248 let inputSize = ((*input).size).wrapping_sub((*input).pos);
10249 let totalInputSize = inputSize.wrapping_add((*cctx).stableIn_notConsumed);
10250 if (*cctx).requestedParams.inBufferMode as core::ffi::c_uint
10251 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint
10252 && endOp as core::ffi::c_uint
10253 == ZSTD_e_continue as core::ffi::c_int as core::ffi::c_uint
10254 && totalInputSize < ZSTD_BLOCKSIZE_MAX as size_t
10255 {
10256 if (*cctx).stableIn_notConsumed != 0 {
10257 if (*input).src != (*cctx).expectedInBuffer.src {
10258 return -(ZSTD_error_stabilityCondition_notRespected as core::ffi::c_int)
10259 as size_t;
10260 }
10261 if (*input).pos != (*cctx).expectedInBuffer.size {
10262 return -(ZSTD_error_stabilityCondition_notRespected as core::ffi::c_int)
10263 as size_t;
10264 }
10265 }
10266 (*input).pos = (*input).size;
10267 (*cctx).expectedInBuffer = *input;
10268 (*cctx).stableIn_notConsumed = ((*cctx).stableIn_notConsumed).wrapping_add(inputSize);
10269 return (if (*cctx).requestedParams.format == Format::ZSTD_f_zstd1 {
10270 6
10271 } else {
10272 2
10273 }) as size_t;
10274 }
10275 let err_code = ZSTD_CCtx_init_compressStream2(cctx, endOp, totalInputSize);
10276 if ERR_isError(err_code) {
10277 return err_code;
10278 }
10279 ZSTD_setBufferExpectations(cctx, output, input);
10280 }
10281 let err_code_0 = ZSTD_checkBufferStability(cctx, output, input, endOp);
10282 if ERR_isError(err_code_0) {
10283 return err_code_0;
10284 }
10285 if (*cctx).appliedParams.nbWorkers > 0 {
10286 let mut flushMin: size_t = 0;
10287 if (*cctx).cParamsChanged != 0 {
10288 ZSTDMT_updateCParams_whileCompressing((*cctx).mtctx, &(*cctx).requestedParams);
10289 (*cctx).cParamsChanged = 0;
10290 }
10291 if (*cctx).stableIn_notConsumed != 0 {
10292 (*input).pos = ((*input).pos).wrapping_sub((*cctx).stableIn_notConsumed);
10293 (*cctx).stableIn_notConsumed = 0;
10294 }
10295 loop {
10296 let ipos = (*input).pos;
10297 let opos = (*output).pos;
10298 flushMin = ZSTDMT_compressStream_generic((*cctx).mtctx, output, input, endOp);
10299 (*cctx).consumedSrcSize = ((*cctx).consumedSrcSize)
10300 .wrapping_add(((*input).pos).wrapping_sub(ipos) as core::ffi::c_ulonglong);
10301 (*cctx).producedCSize = ((*cctx).producedCSize)
10302 .wrapping_add(((*output).pos).wrapping_sub(opos) as core::ffi::c_ulonglong);
10303 if ERR_isError(flushMin)
10304 || endOp as core::ffi::c_uint == ZSTD_e_end as core::ffi::c_int as core::ffi::c_uint
10305 && flushMin == 0
10306 {
10307 if flushMin == 0 {
10308 ZSTD_CCtx_trace(cctx, 0);
10309 }
10310 ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
10311 }
10312 let err_code_1 = flushMin;
10313 if ERR_isError(err_code_1) {
10314 return err_code_1;
10315 }
10316 if endOp as core::ffi::c_uint
10317 == ZSTD_e_continue as core::ffi::c_int as core::ffi::c_uint
10318 {
10319 if (*input).pos != ipos
10320 || (*output).pos != opos
10321 || (*input).pos == (*input).size
10322 || (*output).pos == (*output).size
10323 {
10324 break;
10325 }
10326 } else if flushMin == 0 || (*output).pos == (*output).size {
10327 break;
10328 }
10329 }
10330 ZSTD_setBufferExpectations(cctx, output, input);
10331 return flushMin;
10332 }
10333 let err_code_2 = ZSTD_compressStream_generic(cctx, output, input, endOp);
10334 if ERR_isError(err_code_2) {
10335 return err_code_2;
10336 }
10337 ZSTD_setBufferExpectations(cctx, output, input);
10338 ((*cctx).outBuffContentSize).wrapping_sub((*cctx).outBuffFlushedSize)
10339}
10340#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressStream2_simpleArgs))]
10341pub unsafe extern "C" fn ZSTD_compressStream2_simpleArgs(
10342 cctx: *mut ZSTD_CCtx,
10343 dst: *mut core::ffi::c_void,
10344 dstCapacity: size_t,
10345 dstPos: *mut size_t,
10346 src: *const core::ffi::c_void,
10347 srcSize: size_t,
10348 srcPos: *mut size_t,
10349 endOp: ZSTD_EndDirective,
10350) -> size_t {
10351 let mut output = ZSTD_outBuffer_s {
10352 dst: core::ptr::null_mut::<core::ffi::c_void>(),
10353 size: 0,
10354 pos: 0,
10355 };
10356 let mut input = ZSTD_inBuffer_s {
10357 src: core::ptr::null::<core::ffi::c_void>(),
10358 size: 0,
10359 pos: 0,
10360 };
10361 output.dst = dst;
10362 output.size = dstCapacity;
10363 output.pos = *dstPos;
10364 input.src = src;
10365 input.size = srcSize;
10366 input.pos = *srcPos;
10367 let cErr = ZSTD_compressStream2(cctx, &mut output, &mut input, endOp);
10368 *dstPos = output.pos;
10369 *srcPos = input.pos;
10370 cErr
10371}
10372#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compress2))]
10373pub unsafe extern "C" fn ZSTD_compress2(
10374 cctx: *mut ZSTD_CCtx,
10375 dst: *mut core::ffi::c_void,
10376 dstCapacity: size_t,
10377 src: *const core::ffi::c_void,
10378 srcSize: size_t,
10379) -> size_t {
10380 let originalInBufferMode = (*cctx).requestedParams.inBufferMode;
10381 let originalOutBufferMode = (*cctx).requestedParams.outBufferMode;
10382 ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
10383 (*cctx).requestedParams.inBufferMode = ZSTD_bm_stable;
10384 (*cctx).requestedParams.outBufferMode = ZSTD_bm_stable;
10385 let mut oPos = 0;
10386 let mut iPos = 0;
10387 let result = ZSTD_compressStream2_simpleArgs(
10388 cctx,
10389 dst,
10390 dstCapacity,
10391 &mut oPos,
10392 src,
10393 srcSize,
10394 &mut iPos,
10395 ZSTD_e_end,
10396 );
10397 (*cctx).requestedParams.inBufferMode = originalInBufferMode;
10398 (*cctx).requestedParams.outBufferMode = originalOutBufferMode;
10399 let err_code = result;
10400 if ERR_isError(err_code) {
10401 return err_code;
10402 }
10403 if result != 0 {
10404 return Error::dstSize_tooSmall.to_error_code();
10405 }
10406 oPos
10407}
10408unsafe fn ZSTD_validateSequence(
10409 offBase: u32,
10410 matchLength: u32,
10411 minMatch: u32,
10412 posInSrc: size_t,
10413 windowLog: u32,
10414 dictSize: size_t,
10415 useSequenceProducer: core::ffi::c_int,
10416) -> size_t {
10417 let windowSize = (1) << windowLog;
10418 let offsetBound = if posInSrc > windowSize as size_t {
10419 windowSize as size_t
10420 } else {
10421 posInSrc.wrapping_add(dictSize)
10422 };
10423 let matchLenLowerBound = (if minMatch == 3 || useSequenceProducer != 0 {
10424 3
10425 } else {
10426 4
10427 }) as size_t;
10428 if offBase as size_t > offsetBound.wrapping_add(3) {
10429 return Error::externalSequences_invalid.to_error_code();
10430 }
10431 if (matchLength as size_t) < matchLenLowerBound {
10432 return Error::externalSequences_invalid.to_error_code();
10433 }
10434 0
10435}
10436unsafe fn ZSTD_finalizeOffBase(rawOffset: u32, rep: *const u32, ll0: u32) -> u32 {
10437 let mut offBase = rawOffset.wrapping_add(ZSTD_REP_NUM as u32);
10438 if ll0 == 0 && rawOffset == *rep.offset(0) {
10439 offBase = REPCODE1_TO_OFFBASE as u32;
10440 } else if rawOffset == *rep.offset(1) {
10441 offBase = 2u32.wrapping_sub(ll0);
10442 } else if rawOffset == *rep.offset(2) {
10443 offBase = 3u32.wrapping_sub(ll0);
10444 } else if ll0 != 0 && rawOffset == (*rep.offset(0)).wrapping_sub(1) {
10445 offBase = REPCODE3_TO_OFFBASE as u32;
10446 }
10447 offBase
10448}
10449unsafe fn ZSTD_transferSequences_wBlockDelim(
10450 cctx: *mut ZSTD_CCtx,
10451 seqPos: *mut ZSTD_SequencePosition,
10452 inSeqs: *const ZSTD_Sequence,
10453 inSeqsSize: size_t,
10454 src: *const core::ffi::c_void,
10455 blockSize: size_t,
10456 externalRepSearch: ZSTD_ParamSwitch_e,
10457) -> size_t {
10458 let mut idx = (*seqPos).idx;
10459 let startIdx = idx;
10460 let mut ip = src as *const u8;
10461 let iend = ip.add(blockSize);
10462 let mut updatedRepcodes = repcodes_s { rep: [0; 3] };
10463 let mut dictSize: u32 = 0;
10464 if !((*cctx).cdict).is_null() {
10465 dictSize = (*(*cctx).cdict).dictContentSize as u32;
10466 } else if !((*cctx).prefixDict.dict).is_null() {
10467 dictSize = (*cctx).prefixDict.dictSize as u32;
10468 } else {
10469 dictSize = 0;
10470 }
10471 libc::memcpy(
10472 (updatedRepcodes.rep).as_mut_ptr() as *mut core::ffi::c_void,
10473 ((*(*cctx).blockState.prevCBlock).rep).as_mut_ptr() as *const core::ffi::c_void,
10474 ::core::mem::size_of::<Repcodes_t>(),
10475 );
10476 while (idx as size_t) < inSeqsSize
10477 && ((*inSeqs.offset(idx as isize)).matchLength != 0
10478 || (*inSeqs.offset(idx as isize)).offset != 0)
10479 {
10480 let litLength = (*inSeqs.offset(idx as isize)).litLength;
10481 let matchLength = (*inSeqs.offset(idx as isize)).matchLength;
10482 let mut offBase: u32 = 0;
10483 if externalRepSearch as core::ffi::c_uint
10484 == ZSTD_ps_disable as core::ffi::c_int as core::ffi::c_uint
10485 {
10486 offBase = ((*inSeqs.offset(idx as isize)).offset)
10487 .wrapping_add(ZSTD_REP_NUM as core::ffi::c_uint);
10488 } else {
10489 let ll0 = (litLength == 0) as core::ffi::c_int as u32;
10490 offBase = ZSTD_finalizeOffBase(
10491 (*inSeqs.offset(idx as isize)).offset,
10492 (updatedRepcodes.rep).as_mut_ptr() as *const u32,
10493 ll0,
10494 );
10495 ZSTD_updateRep((updatedRepcodes.rep).as_mut_ptr(), offBase, ll0);
10496 }
10497 if (*cctx).appliedParams.validateSequences != 0 {
10498 (*seqPos).posInSrc =
10499 ((*seqPos).posInSrc).wrapping_add(litLength.wrapping_add(matchLength) as size_t);
10500 let err_code = ZSTD_validateSequence(
10501 offBase,
10502 matchLength,
10503 (*cctx).appliedParams.cParams.minMatch,
10504 (*seqPos).posInSrc,
10505 (*cctx).appliedParams.cParams.windowLog,
10506 dictSize as size_t,
10507 ZSTD_hasExtSeqProd(&(*cctx).appliedParams),
10508 );
10509 if ERR_isError(err_code) {
10510 return err_code;
10511 }
10512 }
10513 if idx.wrapping_sub((*seqPos).idx) as size_t >= (*cctx).seqStore.maxNbSeq {
10514 return Error::externalSequences_invalid.to_error_code();
10515 }
10516 ZSTD_storeSeq(
10517 &mut (*cctx).seqStore,
10518 litLength as size_t,
10519 ip,
10520 iend,
10521 offBase,
10522 matchLength as size_t,
10523 );
10524 ip = ip.offset(matchLength.wrapping_add(litLength) as isize);
10525 idx = idx.wrapping_add(1);
10526 }
10527 if idx as size_t == inSeqsSize {
10528 return Error::externalSequences_invalid.to_error_code();
10529 }
10530 if externalRepSearch as core::ffi::c_uint
10531 == ZSTD_ps_disable as core::ffi::c_int as core::ffi::c_uint
10532 && idx != startIdx
10533 {
10534 let rep = (updatedRepcodes.rep).as_mut_ptr();
10535 let lastSeqIdx = idx.wrapping_sub(1);
10536 if lastSeqIdx >= startIdx.wrapping_add(2) {
10537 *rep.offset(2) = (*inSeqs.offset(lastSeqIdx.wrapping_sub(2) as isize)).offset;
10538 *rep.offset(1) = (*inSeqs.offset(lastSeqIdx.wrapping_sub(1) as isize)).offset;
10539 *rep.offset(0) = (*inSeqs.offset(lastSeqIdx as isize)).offset;
10540 } else if lastSeqIdx == startIdx.wrapping_add(1) {
10541 *rep.offset(2) = *rep.offset(0);
10542 *rep.offset(1) = (*inSeqs.offset(lastSeqIdx.wrapping_sub(1) as isize)).offset;
10543 *rep.offset(0) = (*inSeqs.offset(lastSeqIdx as isize)).offset;
10544 } else {
10545 *rep.offset(2) = *rep.offset(1);
10546 *rep.offset(1) = *rep.offset(0);
10547 *rep.offset(0) = (*inSeqs.offset(lastSeqIdx as isize)).offset;
10548 }
10549 }
10550 libc::memcpy(
10551 ((*(*cctx).blockState.nextCBlock).rep).as_mut_ptr() as *mut core::ffi::c_void,
10552 (updatedRepcodes.rep).as_mut_ptr() as *const core::ffi::c_void,
10553 ::core::mem::size_of::<Repcodes_t>(),
10554 );
10555 if (*inSeqs.offset(idx as isize)).litLength != 0 {
10556 ZSTD_storeLastLiterals(
10557 &mut (*cctx).seqStore,
10558 ip,
10559 (*inSeqs.offset(idx as isize)).litLength as size_t,
10560 );
10561 ip = ip.offset((*inSeqs.offset(idx as isize)).litLength as isize);
10562 (*seqPos).posInSrc =
10563 ((*seqPos).posInSrc).wrapping_add((*inSeqs.offset(idx as isize)).litLength as size_t);
10564 }
10565 if ip != iend {
10566 return Error::externalSequences_invalid.to_error_code();
10567 }
10568 (*seqPos).idx = idx.wrapping_add(1);
10569 blockSize
10570}
10571unsafe fn ZSTD_transferSequences_noDelim(
10572 cctx: *mut ZSTD_CCtx,
10573 seqPos: *mut ZSTD_SequencePosition,
10574 inSeqs: *const ZSTD_Sequence,
10575 inSeqsSize: size_t,
10576 src: *const core::ffi::c_void,
10577 blockSize: size_t,
10578 externalRepSearch: ZSTD_ParamSwitch_e,
10579) -> size_t {
10580 let mut idx = (*seqPos).idx;
10581 let mut startPosInSequence = (*seqPos).posInSequence;
10582 let mut endPosInSequence = ((*seqPos).posInSequence).wrapping_add(blockSize as u32);
10583 let mut dictSize: size_t = 0;
10584 let istart = src as *const u8;
10585 let mut ip = istart;
10586 let mut iend = istart.add(blockSize);
10587 let mut updatedRepcodes = repcodes_s { rep: [0; 3] };
10588 let mut bytesAdjustment = 0;
10589 let mut finalMatchSplit = 0;
10590 if !((*cctx).cdict).is_null() {
10591 dictSize = (*(*cctx).cdict).dictContentSize;
10592 } else if !((*cctx).prefixDict.dict).is_null() {
10593 dictSize = (*cctx).prefixDict.dictSize;
10594 } else {
10595 dictSize = 0;
10596 }
10597 libc::memcpy(
10598 (updatedRepcodes.rep).as_mut_ptr() as *mut core::ffi::c_void,
10599 ((*(*cctx).blockState.prevCBlock).rep).as_mut_ptr() as *const core::ffi::c_void,
10600 ::core::mem::size_of::<Repcodes_t>(),
10601 );
10602 while endPosInSequence != 0 && (idx as size_t) < inSeqsSize && finalMatchSplit == 0 {
10603 let currSeq = *inSeqs.offset(idx as isize);
10604 let mut litLength = currSeq.litLength;
10605 let mut matchLength = currSeq.matchLength;
10606 let rawOffset = currSeq.offset;
10607 let mut offBase: u32 = 0;
10608 if endPosInSequence >= (currSeq.litLength).wrapping_add(currSeq.matchLength) {
10609 if startPosInSequence >= litLength {
10610 startPosInSequence = startPosInSequence.wrapping_sub(litLength);
10611 litLength = 0;
10612 matchLength = matchLength.wrapping_sub(startPosInSequence);
10613 } else {
10614 litLength = litLength.wrapping_sub(startPosInSequence);
10615 }
10616 endPosInSequence = (endPosInSequence as core::ffi::c_uint)
10617 .wrapping_sub((currSeq.litLength).wrapping_add(currSeq.matchLength));
10618 startPosInSequence = 0;
10619 } else {
10620 if endPosInSequence <= litLength {
10621 break;
10622 }
10623 let mut firstHalfMatchLength: u32 = 0;
10624 litLength = if startPosInSequence >= litLength {
10625 0
10626 } else {
10627 litLength.wrapping_sub(startPosInSequence)
10628 };
10629 firstHalfMatchLength = endPosInSequence
10630 .wrapping_sub(startPosInSequence)
10631 .wrapping_sub(litLength);
10632 if matchLength as size_t > blockSize
10633 && firstHalfMatchLength >= (*cctx).appliedParams.cParams.minMatch
10634 {
10635 let secondHalfMatchLength = (currSeq.matchLength)
10636 .wrapping_add(currSeq.litLength)
10637 .wrapping_sub(endPosInSequence);
10638 if secondHalfMatchLength < (*cctx).appliedParams.cParams.minMatch {
10639 endPosInSequence = (endPosInSequence as core::ffi::c_uint).wrapping_sub(
10640 ((*cctx).appliedParams.cParams.minMatch)
10641 .wrapping_sub(secondHalfMatchLength),
10642 );
10643 bytesAdjustment = ((*cctx).appliedParams.cParams.minMatch)
10644 .wrapping_sub(secondHalfMatchLength);
10645 firstHalfMatchLength = firstHalfMatchLength.wrapping_sub(bytesAdjustment);
10646 }
10647 matchLength = firstHalfMatchLength;
10648 finalMatchSplit = 1;
10649 } else {
10650 bytesAdjustment = endPosInSequence.wrapping_sub(currSeq.litLength);
10651 endPosInSequence = currSeq.litLength;
10652 break;
10653 }
10654 }
10655 let ll0 = (litLength == 0) as core::ffi::c_int as u32;
10656 offBase = ZSTD_finalizeOffBase(
10657 rawOffset,
10658 (updatedRepcodes.rep).as_mut_ptr() as *const u32,
10659 ll0,
10660 );
10661 ZSTD_updateRep((updatedRepcodes.rep).as_mut_ptr(), offBase, ll0);
10662 if (*cctx).appliedParams.validateSequences != 0 {
10663 (*seqPos).posInSrc =
10664 ((*seqPos).posInSrc).wrapping_add(litLength.wrapping_add(matchLength) as size_t);
10665 let err_code = ZSTD_validateSequence(
10666 offBase,
10667 matchLength,
10668 (*cctx).appliedParams.cParams.minMatch,
10669 (*seqPos).posInSrc,
10670 (*cctx).appliedParams.cParams.windowLog,
10671 dictSize,
10672 ZSTD_hasExtSeqProd(&(*cctx).appliedParams),
10673 );
10674 if ERR_isError(err_code) {
10675 return err_code;
10676 }
10677 }
10678 if idx.wrapping_sub((*seqPos).idx) as size_t >= (*cctx).seqStore.maxNbSeq {
10679 return Error::externalSequences_invalid.to_error_code();
10680 }
10681 ZSTD_storeSeq(
10682 &mut (*cctx).seqStore,
10683 litLength as size_t,
10684 ip,
10685 iend,
10686 offBase,
10687 matchLength as size_t,
10688 );
10689 ip = ip.offset(matchLength.wrapping_add(litLength) as isize);
10690 if finalMatchSplit == 0 {
10691 idx = idx.wrapping_add(1);
10692 }
10693 }
10694 (*seqPos).idx = idx;
10695 (*seqPos).posInSequence = endPosInSequence;
10696 libc::memcpy(
10697 ((*(*cctx).blockState.nextCBlock).rep).as_mut_ptr() as *mut core::ffi::c_void,
10698 (updatedRepcodes.rep).as_mut_ptr() as *const core::ffi::c_void,
10699 ::core::mem::size_of::<Repcodes_t>(),
10700 );
10701 iend = iend.offset(-(bytesAdjustment as isize));
10702 if ip != iend {
10703 let lastLLSize = iend.offset_from(ip) as core::ffi::c_long as u32;
10704 ZSTD_storeLastLiterals(&mut (*cctx).seqStore, ip, lastLLSize as size_t);
10705 (*seqPos).posInSrc = ((*seqPos).posInSrc).wrapping_add(lastLLSize as size_t);
10706 }
10707 iend.offset_from(istart) as size_t
10708}
10709unsafe fn ZSTD_selectSequenceCopier(mode: ZSTD_SequenceFormat_e) -> ZSTD_SequenceCopier_f {
10710 if mode as core::ffi::c_uint
10711 == ZSTD_sf_explicitBlockDelimiters as core::ffi::c_int as core::ffi::c_uint
10712 {
10713 return Some(
10714 ZSTD_transferSequences_wBlockDelim
10715 as unsafe fn(
10716 *mut ZSTD_CCtx,
10717 *mut ZSTD_SequencePosition,
10718 *const ZSTD_Sequence,
10719 size_t,
10720 *const core::ffi::c_void,
10721 size_t,
10722 ZSTD_ParamSwitch_e,
10723 ) -> size_t,
10724 );
10725 }
10726 Some(
10727 ZSTD_transferSequences_noDelim
10728 as unsafe fn(
10729 *mut ZSTD_CCtx,
10730 *mut ZSTD_SequencePosition,
10731 *const ZSTD_Sequence,
10732 size_t,
10733 *const core::ffi::c_void,
10734 size_t,
10735 ZSTD_ParamSwitch_e,
10736 ) -> size_t,
10737 )
10738}
10739unsafe fn blockSize_explicitDelimiter(
10740 inSeqs: *const ZSTD_Sequence,
10741 inSeqsSize: size_t,
10742 seqPos: ZSTD_SequencePosition,
10743) -> size_t {
10744 let mut end = 0;
10745 let mut blockSize = 0 as size_t;
10746 let mut spos = seqPos.idx as size_t;
10747 while spos < inSeqsSize {
10748 end = ((*inSeqs.add(spos)).offset == 0) as core::ffi::c_int;
10749 blockSize = blockSize.wrapping_add(
10750 ((*inSeqs.add(spos)).litLength).wrapping_add((*inSeqs.add(spos)).matchLength) as size_t,
10751 );
10752 if end != 0 {
10753 if (*inSeqs.add(spos)).matchLength != 0 {
10754 return Error::externalSequences_invalid.to_error_code();
10755 }
10756 break;
10757 } else {
10758 spos = spos.wrapping_add(1);
10759 }
10760 }
10761 if end == 0 {
10762 return Error::externalSequences_invalid.to_error_code();
10763 }
10764 blockSize
10765}
10766unsafe fn determine_blockSize(
10767 mode: ZSTD_SequenceFormat_e,
10768 blockSize: size_t,
10769 remaining: size_t,
10770 inSeqs: *const ZSTD_Sequence,
10771 inSeqsSize: size_t,
10772 seqPos: ZSTD_SequencePosition,
10773) -> size_t {
10774 if mode as core::ffi::c_uint
10775 == ZSTD_sf_noBlockDelimiters as core::ffi::c_int as core::ffi::c_uint
10776 {
10777 return if remaining < blockSize {
10778 remaining
10779 } else {
10780 blockSize
10781 };
10782 }
10783 let explicitBlockSize = blockSize_explicitDelimiter(inSeqs, inSeqsSize, seqPos);
10784 let err_code = explicitBlockSize;
10785 if ERR_isError(err_code) {
10786 return err_code;
10787 }
10788 if explicitBlockSize > blockSize {
10789 return Error::externalSequences_invalid.to_error_code();
10790 }
10791 if explicitBlockSize > remaining {
10792 return Error::externalSequences_invalid.to_error_code();
10793 }
10794 explicitBlockSize
10795}
10796unsafe fn ZSTD_compressSequences_internal(
10797 cctx: *mut ZSTD_CCtx,
10798 dst: *mut core::ffi::c_void,
10799 mut dstCapacity: size_t,
10800 inSeqs: *const ZSTD_Sequence,
10801 inSeqsSize: size_t,
10802 src: *const core::ffi::c_void,
10803 srcSize: size_t,
10804) -> size_t {
10805 let mut cSize = 0 as size_t;
10806 let mut remaining = srcSize;
10807 let mut seqPos = {
10808 ZSTD_SequencePosition {
10809 idx: 0,
10810 posInSequence: 0,
10811 posInSrc: 0,
10812 }
10813 };
10814 let mut ip = src as *const u8;
10815 let mut op = dst as *mut u8;
10816 let sequenceCopier = ZSTD_selectSequenceCopier((*cctx).appliedParams.blockDelimiters);
10817 if remaining == 0 {
10818 let cBlockHeader24 = 1u32.wrapping_add((bt_raw as core::ffi::c_int as u32) << 1);
10819 if dstCapacity < 4 {
10820 return Error::dstSize_tooSmall.to_error_code();
10821 }
10822 MEM_writeLE32(op as *mut core::ffi::c_void, cBlockHeader24);
10823 op = op.add(ZSTD_blockHeaderSize);
10824 dstCapacity = dstCapacity.wrapping_sub(ZSTD_blockHeaderSize);
10825 cSize = cSize.wrapping_add(ZSTD_blockHeaderSize);
10826 }
10827 while remaining != 0 {
10828 let mut compressedSeqsSize: size_t = 0;
10829 let mut cBlockSize: size_t = 0;
10830 let mut blockSize = determine_blockSize(
10831 (*cctx).appliedParams.blockDelimiters,
10832 (*cctx).blockSizeMax,
10833 remaining,
10834 inSeqs,
10835 inSeqsSize,
10836 seqPos,
10837 );
10838 let lastBlock = (blockSize == remaining) as core::ffi::c_int as u32;
10839 let err_code = blockSize;
10840 if ERR_isError(err_code) {
10841 return err_code;
10842 }
10843 ZSTD_resetSeqStore(&mut (*cctx).seqStore);
10844 blockSize = sequenceCopier.unwrap_unchecked()(
10845 cctx,
10846 &mut seqPos,
10847 inSeqs,
10848 inSeqsSize,
10849 ip as *const core::ffi::c_void,
10850 blockSize,
10851 (*cctx).appliedParams.searchForExternalRepcodes,
10852 );
10853 let err_code_0 = blockSize;
10854 if ERR_isError(err_code_0) {
10855 return err_code_0;
10856 }
10857 if blockSize
10858 < (MIN_CBLOCK_SIZE as size_t)
10859 .wrapping_add(ZSTD_blockHeaderSize)
10860 .wrapping_add(1)
10861 .wrapping_add(1)
10862 {
10863 cBlockSize = ZSTD_noCompressBlock(
10864 op as *mut core::ffi::c_void,
10865 dstCapacity,
10866 ip as *const core::ffi::c_void,
10867 blockSize,
10868 lastBlock,
10869 );
10870 let err_code_1 = cBlockSize;
10871 if ERR_isError(err_code_1) {
10872 return err_code_1;
10873 }
10874 cSize = cSize.wrapping_add(cBlockSize);
10875 ip = ip.add(blockSize);
10876 op = op.add(cBlockSize);
10877 remaining = remaining.wrapping_sub(blockSize);
10878 dstCapacity = dstCapacity.wrapping_sub(cBlockSize);
10879 } else {
10880 if dstCapacity < ZSTD_blockHeaderSize {
10881 return Error::dstSize_tooSmall.to_error_code();
10882 }
10883 compressedSeqsSize = ZSTD_entropyCompressSeqStore(
10884 &(*cctx).seqStore,
10885 &(*(*cctx).blockState.prevCBlock).entropy,
10886 &mut (*(*cctx).blockState.nextCBlock).entropy,
10887 &(*cctx).appliedParams,
10888 op.add(ZSTD_blockHeaderSize) as *mut core::ffi::c_void,
10889 dstCapacity.wrapping_sub(ZSTD_blockHeaderSize),
10890 blockSize,
10891 (*cctx).tmpWorkspace,
10892 (*cctx).tmpWkspSize,
10893 (*cctx).bmi2,
10894 );
10895 let err_code_2 = compressedSeqsSize;
10896 if ERR_isError(err_code_2) {
10897 return err_code_2;
10898 }
10899 if (*cctx).isFirstBlock == 0
10900 && ZSTD_maybeRLE(&(*cctx).seqStore) != 0
10901 && ZSTD_isRLE(ip, blockSize) != 0
10902 {
10903 compressedSeqsSize = 1;
10904 }
10905 if compressedSeqsSize == 0 {
10906 cBlockSize = ZSTD_noCompressBlock(
10907 op as *mut core::ffi::c_void,
10908 dstCapacity,
10909 ip as *const core::ffi::c_void,
10910 blockSize,
10911 lastBlock,
10912 );
10913 let err_code_3 = cBlockSize;
10914 if ERR_isError(err_code_3) {
10915 return err_code_3;
10916 }
10917 } else if compressedSeqsSize == 1 {
10918 cBlockSize = ZSTD_rleCompressBlock(
10919 op as *mut core::ffi::c_void,
10920 dstCapacity,
10921 *ip,
10922 blockSize,
10923 lastBlock,
10924 );
10925 let err_code_4 = cBlockSize;
10926 if ERR_isError(err_code_4) {
10927 return err_code_4;
10928 }
10929 } else {
10930 let mut cBlockHeader: u32 = 0;
10931 ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*cctx).blockState);
10932 if (*(*cctx).blockState.prevCBlock)
10933 .entropy
10934 .fse
10935 .offcode_repeatMode as core::ffi::c_uint
10936 == FSE_repeat_valid as core::ffi::c_int as core::ffi::c_uint
10937 {
10938 (*(*cctx).blockState.prevCBlock)
10939 .entropy
10940 .fse
10941 .offcode_repeatMode = FSE_repeat_check;
10942 }
10943 cBlockHeader = lastBlock
10944 .wrapping_add((bt_compressed as core::ffi::c_int as u32) << 1)
10945 .wrapping_add((compressedSeqsSize << 3) as u32);
10946 MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader);
10947 cBlockSize = ZSTD_blockHeaderSize.wrapping_add(compressedSeqsSize);
10948 }
10949 cSize = cSize.wrapping_add(cBlockSize);
10950 if lastBlock != 0 {
10951 break;
10952 }
10953 ip = ip.add(blockSize);
10954 op = op.add(cBlockSize);
10955 remaining = remaining.wrapping_sub(blockSize);
10956 dstCapacity = dstCapacity.wrapping_sub(cBlockSize);
10957 (*cctx).isFirstBlock = 0;
10958 }
10959 }
10960 cSize
10961}
10962#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressSequences))]
10963pub unsafe extern "C" fn ZSTD_compressSequences(
10964 cctx: *mut ZSTD_CCtx,
10965 dst: *mut core::ffi::c_void,
10966 mut dstCapacity: size_t,
10967 inSeqs: *const ZSTD_Sequence,
10968 inSeqsSize: size_t,
10969 src: *const core::ffi::c_void,
10970 srcSize: size_t,
10971) -> size_t {
10972 let mut op = dst as *mut u8;
10973 let mut cSize = 0 as size_t;
10974 let err_code = ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, srcSize);
10975 if ERR_isError(err_code) {
10976 return err_code;
10977 }
10978 let frameHeaderSize = ZSTD_writeFrameHeader(
10979 op as *mut core::ffi::c_void,
10980 dstCapacity,
10981 &(*cctx).appliedParams,
10982 srcSize as u64,
10983 (*cctx).dictID,
10984 );
10985 op = op.add(frameHeaderSize);
10986 dstCapacity = dstCapacity.wrapping_sub(frameHeaderSize);
10987 cSize = cSize.wrapping_add(frameHeaderSize);
10988 if (*cctx).appliedParams.fParams.checksumFlag != 0 && srcSize != 0 {
10989 ZSTD_XXH64_update(&mut (*cctx).xxhState, src, srcSize);
10990 }
10991 let cBlocksSize = ZSTD_compressSequences_internal(
10992 cctx,
10993 op as *mut core::ffi::c_void,
10994 dstCapacity,
10995 inSeqs,
10996 inSeqsSize,
10997 src,
10998 srcSize,
10999 );
11000 let err_code_0 = cBlocksSize;
11001 if ERR_isError(err_code_0) {
11002 return err_code_0;
11003 }
11004 cSize = cSize.wrapping_add(cBlocksSize);
11005 dstCapacity = dstCapacity.wrapping_sub(cBlocksSize);
11006 if (*cctx).appliedParams.fParams.checksumFlag != 0 {
11007 let checksum = ZSTD_XXH64_digest(&mut (*cctx).xxhState) as u32;
11008 if dstCapacity < 4 {
11009 return Error::dstSize_tooSmall.to_error_code();
11010 }
11011 MEM_writeLE32(
11012 (dst as *mut core::ffi::c_char).add(cSize) as *mut core::ffi::c_void,
11013 checksum,
11014 );
11015 cSize = cSize.wrapping_add(4);
11016 }
11017 cSize
11018}
11019pub unsafe fn convertSequences_noRepcodes(
11020 dstSeqs: *mut SeqDef,
11021 inSeqs: *const ZSTD_Sequence,
11022 nbSequences: size_t,
11023) -> size_t {
11024 let mut longLen = 0;
11025 let mut n: size_t = 0;
11026 n = 0;
11027 while n < nbSequences {
11028 (*dstSeqs.add(n)).offBase =
11029 ((*inSeqs.add(n)).offset).wrapping_add(ZSTD_REP_NUM as core::ffi::c_uint);
11030 (*dstSeqs.add(n)).litLength = (*inSeqs.add(n)).litLength as u16;
11031 (*dstSeqs.add(n)).mlBase =
11032 ((*inSeqs.add(n)).matchLength).wrapping_sub(MINMATCH as core::ffi::c_uint) as u16;
11033 if ((*inSeqs.add(n)).matchLength > (65535 + 3) as core::ffi::c_uint) as core::ffi::c_int
11034 as core::ffi::c_long
11035 != 0
11036 {
11037 longLen = n.wrapping_add(1);
11038 }
11039 if ((*inSeqs.add(n)).litLength > 65535) as core::ffi::c_int as core::ffi::c_long != 0 {
11040 longLen = n.wrapping_add(nbSequences).wrapping_add(1);
11041 }
11042 n = n.wrapping_add(1);
11043 }
11044 longLen
11045}
11046pub unsafe fn ZSTD_convertBlockSequences(
11047 cctx: *mut ZSTD_CCtx,
11048 inSeqs: *const ZSTD_Sequence,
11049 nbSequences: size_t,
11050 repcodeResolution: core::ffi::c_int,
11051) -> size_t {
11052 let mut updatedRepcodes = repcodes_s { rep: [0; 3] };
11053 let mut seqNb = 0;
11054 if nbSequences >= (*cctx).seqStore.maxNbSeq {
11055 return Error::externalSequences_invalid.to_error_code();
11056 }
11057 libc::memcpy(
11058 (updatedRepcodes.rep).as_mut_ptr() as *mut core::ffi::c_void,
11059 ((*(*cctx).blockState.prevCBlock).rep).as_mut_ptr() as *const core::ffi::c_void,
11060 ::core::mem::size_of::<Repcodes_t>(),
11061 );
11062 if repcodeResolution == 0 {
11063 let longl = convertSequences_noRepcodes(
11064 (*cctx).seqStore.sequencesStart,
11065 inSeqs,
11066 nbSequences.wrapping_sub(1),
11067 );
11068 (*cctx).seqStore.sequences = ((*cctx).seqStore.sequencesStart)
11069 .add(nbSequences)
11070 .offset(-(1));
11071 if longl != 0 {
11072 if longl <= nbSequences.wrapping_sub(1) {
11073 (*cctx).seqStore.longLengthType = ZSTD_llt_matchLength;
11074 (*cctx).seqStore.longLengthPos = longl.wrapping_sub(1) as u32;
11075 } else {
11076 (*cctx).seqStore.longLengthType = ZSTD_llt_literalLength;
11077 (*cctx).seqStore.longLengthPos = longl
11078 .wrapping_sub(nbSequences.wrapping_sub(1))
11079 .wrapping_sub(1) as u32;
11080 }
11081 }
11082 } else {
11083 seqNb = 0;
11084 while seqNb < nbSequences.wrapping_sub(1) {
11085 let litLength = (*inSeqs.add(seqNb)).litLength;
11086 let matchLength = (*inSeqs.add(seqNb)).matchLength;
11087 let ll0 = (litLength == 0) as core::ffi::c_int as u32;
11088 let offBase = ZSTD_finalizeOffBase(
11089 (*inSeqs.add(seqNb)).offset,
11090 (updatedRepcodes.rep).as_mut_ptr() as *const u32,
11091 ll0,
11092 );
11093 ZSTD_storeSeqOnly(
11094 &mut (*cctx).seqStore,
11095 litLength as size_t,
11096 offBase,
11097 matchLength as size_t,
11098 );
11099 ZSTD_updateRep((updatedRepcodes.rep).as_mut_ptr(), offBase, ll0);
11100 seqNb = seqNb.wrapping_add(1);
11101 }
11102 }
11103 if repcodeResolution == 0 && nbSequences > 1 {
11104 let rep = (updatedRepcodes.rep).as_mut_ptr();
11105 if nbSequences >= 4 {
11106 let lastSeqIdx = (nbSequences as u32).wrapping_sub(2);
11107 *rep.offset(2) = (*inSeqs.offset(lastSeqIdx.wrapping_sub(2) as isize)).offset;
11108 *rep.offset(1) = (*inSeqs.offset(lastSeqIdx.wrapping_sub(1) as isize)).offset;
11109 *rep.offset(0) = (*inSeqs.offset(lastSeqIdx as isize)).offset;
11110 } else if nbSequences == 3 {
11111 *rep.offset(2) = *rep.offset(0);
11112 *rep.offset(1) = (*inSeqs.offset(0)).offset;
11113 *rep.offset(0) = (*inSeqs.offset(1)).offset;
11114 } else {
11115 *rep.offset(2) = *rep.offset(1);
11116 *rep.offset(1) = *rep.offset(0);
11117 *rep.offset(0) = (*inSeqs.offset(0)).offset;
11118 }
11119 }
11120 libc::memcpy(
11121 ((*(*cctx).blockState.nextCBlock).rep).as_mut_ptr() as *mut core::ffi::c_void,
11122 (updatedRepcodes.rep).as_mut_ptr() as *const core::ffi::c_void,
11123 ::core::mem::size_of::<Repcodes_t>(),
11124 );
11125 0
11126}
11127#[inline(always)]
11128unsafe fn matchLengthHalfIsZero(litMatchLength: u64) -> core::ffi::c_int {
11129 if MEM_isLittleEndian() != 0 {
11130 (litMatchLength as core::ffi::c_ulonglong <= 0xffffffff as core::ffi::c_ulonglong)
11131 as core::ffi::c_int
11132 } else {
11133 (litMatchLength as u32 == 0) as core::ffi::c_int
11134 }
11135}
11136pub unsafe fn ZSTD_get1BlockSummary(seqs: *const ZSTD_Sequence, nbSeqs: size_t) -> BlockSummary {
11137 let mut current_block: u64;
11138 let mut litMatchSize0 = 0u64;
11139 let mut litMatchSize1 = 0u64;
11140 let mut litMatchSize2 = 0u64;
11141 let mut litMatchSize3 = 0u64;
11142 let mut n = 0 as size_t;
11143 if nbSeqs > 3 as size_t {
11144 loop {
11145 let mut litMatchLength = MEM_read64(
11146 &(*seqs.add(n)).litLength as *const core::ffi::c_uint as *const core::ffi::c_void,
11147 );
11148 litMatchSize0 = litMatchSize0.wrapping_add(litMatchLength);
11149 if matchLengthHalfIsZero(litMatchLength) != 0 {
11150 current_block = 13744635599856597681;
11151 break;
11152 }
11153 litMatchLength = MEM_read64(
11154 &(*seqs.add(n.wrapping_add(1))).litLength as *const core::ffi::c_uint
11155 as *const core::ffi::c_void,
11156 );
11157 litMatchSize1 = litMatchSize1.wrapping_add(litMatchLength);
11158 if matchLengthHalfIsZero(litMatchLength) != 0 {
11159 n = n.wrapping_add(1);
11160 current_block = 13744635599856597681;
11161 break;
11162 } else {
11163 litMatchLength = MEM_read64(
11164 &(*seqs.add(n.wrapping_add(2))).litLength as *const core::ffi::c_uint
11165 as *const core::ffi::c_void,
11166 );
11167 litMatchSize2 = litMatchSize2.wrapping_add(litMatchLength);
11168 if matchLengthHalfIsZero(litMatchLength) != 0 {
11169 n = n.wrapping_add(2);
11170 current_block = 13744635599856597681;
11171 break;
11172 } else {
11173 litMatchLength = MEM_read64(
11174 &(*seqs.add(n.wrapping_add(3))).litLength as *const core::ffi::c_uint
11175 as *const core::ffi::c_void,
11176 );
11177 litMatchSize3 = litMatchSize3.wrapping_add(litMatchLength);
11178 if matchLengthHalfIsZero(litMatchLength) != 0 {
11179 n = n.wrapping_add(3);
11180 current_block = 13744635599856597681;
11181 break;
11182 } else {
11183 n = n.wrapping_add(4);
11184 if n >= nbSeqs.wrapping_sub(3) {
11185 current_block = 2668756484064249700;
11186 break;
11187 }
11188 }
11189 }
11190 }
11191 }
11192 } else {
11193 current_block = 2668756484064249700;
11194 }
11195 loop {
11196 match current_block {
11197 13744635599856597681 => {
11198 litMatchSize0 = litMatchSize0.wrapping_add(
11199 litMatchSize1
11200 .wrapping_add(litMatchSize2)
11201 .wrapping_add(litMatchSize3),
11202 );
11203 let mut bs_0 = BlockSummary {
11204 nbSequences: 0,
11205 blockSize: 0,
11206 litSize: 0,
11207 };
11208 bs_0.nbSequences = n.wrapping_add(1);
11209 if MEM_isLittleEndian() != 0 {
11210 bs_0.litSize = litMatchSize0 as u32 as size_t;
11211 bs_0.blockSize =
11212 (bs_0.litSize as u64).wrapping_add(litMatchSize0 >> 32) as usize;
11213 } else {
11214 bs_0.litSize = (litMatchSize0 >> 32) as usize;
11215 bs_0.blockSize = (bs_0.litSize).wrapping_add(litMatchSize0 as u32 as size_t);
11216 }
11217 return bs_0;
11218 }
11219 _ => {
11220 if n < nbSeqs {
11221 let litMatchLength_0 = MEM_read64(
11222 &(*seqs.add(n)).litLength as *const core::ffi::c_uint
11223 as *const core::ffi::c_void,
11224 );
11225 litMatchSize0 = litMatchSize0.wrapping_add(litMatchLength_0);
11226 if matchLengthHalfIsZero(litMatchLength_0) != 0 {
11227 current_block = 13744635599856597681;
11228 continue;
11229 }
11230 n = n.wrapping_add(1);
11231 current_block = 2668756484064249700;
11232 } else {
11233 let mut bs = BlockSummary {
11234 nbSequences: 0,
11235 blockSize: 0,
11236 litSize: 0,
11237 };
11238 bs.nbSequences = Error::externalSequences_invalid.to_error_code();
11239 return bs;
11240 }
11241 }
11242 }
11243 }
11244}
11245unsafe fn ZSTD_compressSequencesAndLiterals_internal(
11246 cctx: *mut ZSTD_CCtx,
11247 dst: *mut core::ffi::c_void,
11248 mut dstCapacity: size_t,
11249 mut inSeqs: *const ZSTD_Sequence,
11250 mut nbSequences: size_t,
11251 mut literals: *const core::ffi::c_void,
11252 mut litSize: size_t,
11253 srcSize: size_t,
11254) -> size_t {
11255 let mut remaining = srcSize;
11256 let mut cSize = 0 as size_t;
11257 let mut op = dst as *mut u8;
11258 let repcodeResolution = ((*cctx).appliedParams.searchForExternalRepcodes as core::ffi::c_uint
11259 == ZSTD_ps_enable as core::ffi::c_int as core::ffi::c_uint)
11260 as core::ffi::c_int;
11261 if nbSequences == 0 {
11262 return Error::externalSequences_invalid.to_error_code();
11263 }
11264 if nbSequences == 1 && (*inSeqs.offset(0)).litLength == 0 {
11265 let cBlockHeader24 = 1u32.wrapping_add((bt_raw as core::ffi::c_int as u32) << 1);
11266 if dstCapacity < 3 {
11267 return Error::dstSize_tooSmall.to_error_code();
11268 }
11269 MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader24);
11270 op = op.add(ZSTD_blockHeaderSize);
11271 dstCapacity = dstCapacity.wrapping_sub(ZSTD_blockHeaderSize);
11272 cSize = cSize.wrapping_add(ZSTD_blockHeaderSize);
11273 }
11274 while nbSequences != 0 {
11275 let mut compressedSeqsSize: size_t = 0;
11276 let mut cBlockSize: size_t = 0;
11277 let mut conversionStatus: size_t = 0;
11278 let block = ZSTD_get1BlockSummary(inSeqs, nbSequences);
11279 let lastBlock = (block.nbSequences == nbSequences) as core::ffi::c_int as u32;
11280 let err_code = block.nbSequences;
11281 if ERR_isError(err_code) {
11282 return err_code;
11283 }
11284 if block.litSize > litSize {
11285 return Error::externalSequences_invalid.to_error_code();
11286 }
11287 ZSTD_resetSeqStore(&mut (*cctx).seqStore);
11288 conversionStatus =
11289 ZSTD_convertBlockSequences(cctx, inSeqs, block.nbSequences, repcodeResolution);
11290 let err_code_0 = conversionStatus;
11291 if ERR_isError(err_code_0) {
11292 return err_code_0;
11293 }
11294 inSeqs = inSeqs.add(block.nbSequences);
11295 nbSequences = nbSequences.wrapping_sub(block.nbSequences);
11296 remaining = remaining.wrapping_sub(block.blockSize);
11297 if dstCapacity < ZSTD_blockHeaderSize {
11298 return Error::dstSize_tooSmall.to_error_code();
11299 }
11300 compressedSeqsSize = ZSTD_entropyCompressSeqStore_internal(
11301 op.add(ZSTD_blockHeaderSize) as *mut core::ffi::c_void,
11302 dstCapacity.wrapping_sub(ZSTD_blockHeaderSize),
11303 literals,
11304 block.litSize,
11305 &(*cctx).seqStore,
11306 &(*(*cctx).blockState.prevCBlock).entropy,
11307 &mut (*(*cctx).blockState.nextCBlock).entropy,
11308 &(*cctx).appliedParams,
11309 (*cctx).tmpWorkspace,
11310 (*cctx).tmpWkspSize,
11311 (*cctx).bmi2,
11312 );
11313 let err_code_1 = compressedSeqsSize;
11314 if ERR_isError(err_code_1) {
11315 return err_code_1;
11316 }
11317 if compressedSeqsSize > (*cctx).blockSizeMax {
11318 compressedSeqsSize = 0;
11319 }
11320 litSize = litSize.wrapping_sub(block.litSize);
11321 literals =
11322 (literals as *const core::ffi::c_char).add(block.litSize) as *const core::ffi::c_void;
11323 if compressedSeqsSize == 0 {
11324 return Error::cannotProduce_uncompressedBlock.to_error_code();
11325 } else {
11326 let mut cBlockHeader: u32 = 0;
11327 ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*cctx).blockState);
11328 if (*(*cctx).blockState.prevCBlock)
11329 .entropy
11330 .fse
11331 .offcode_repeatMode as core::ffi::c_uint
11332 == FSE_repeat_valid as core::ffi::c_int as core::ffi::c_uint
11333 {
11334 (*(*cctx).blockState.prevCBlock)
11335 .entropy
11336 .fse
11337 .offcode_repeatMode = FSE_repeat_check;
11338 }
11339 cBlockHeader = lastBlock
11340 .wrapping_add((bt_compressed as core::ffi::c_int as u32) << 1)
11341 .wrapping_add((compressedSeqsSize << 3) as u32);
11342 MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader);
11343 cBlockSize = ZSTD_blockHeaderSize.wrapping_add(compressedSeqsSize);
11344 }
11345 cSize = cSize.wrapping_add(cBlockSize);
11346 op = op.add(cBlockSize);
11347 dstCapacity = dstCapacity.wrapping_sub(cBlockSize);
11348 (*cctx).isFirstBlock = 0;
11349 if lastBlock != 0 {
11350 break;
11351 }
11352 }
11353 if litSize != 0 {
11354 return Error::externalSequences_invalid.to_error_code();
11355 }
11356 if remaining != 0 {
11357 return Error::externalSequences_invalid.to_error_code();
11358 }
11359 cSize
11360}
11361#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_compressSequencesAndLiterals))]
11362pub unsafe extern "C" fn ZSTD_compressSequencesAndLiterals(
11363 cctx: *mut ZSTD_CCtx,
11364 dst: *mut core::ffi::c_void,
11365 mut dstCapacity: size_t,
11366 inSeqs: *const ZSTD_Sequence,
11367 inSeqsSize: size_t,
11368 literals: *const core::ffi::c_void,
11369 litSize: size_t,
11370 litCapacity: size_t,
11371 decompressedSize: size_t,
11372) -> size_t {
11373 let mut op = dst as *mut u8;
11374 let mut cSize = 0 as size_t;
11375 if litCapacity < litSize {
11376 return Error::workSpace_tooSmall.to_error_code();
11377 }
11378 let err_code = ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, decompressedSize);
11379 if ERR_isError(err_code) {
11380 return err_code;
11381 }
11382 if (*cctx).appliedParams.blockDelimiters as core::ffi::c_uint
11383 == ZSTD_sf_noBlockDelimiters as core::ffi::c_int as core::ffi::c_uint
11384 {
11385 return Error::frameParameter_unsupported.to_error_code();
11386 }
11387 if (*cctx).appliedParams.validateSequences != 0 {
11388 return Error::parameter_unsupported.to_error_code();
11389 }
11390 if (*cctx).appliedParams.fParams.checksumFlag != 0 {
11391 return Error::frameParameter_unsupported.to_error_code();
11392 }
11393 let frameHeaderSize = ZSTD_writeFrameHeader(
11394 op as *mut core::ffi::c_void,
11395 dstCapacity,
11396 &(*cctx).appliedParams,
11397 decompressedSize as u64,
11398 (*cctx).dictID,
11399 );
11400 op = op.add(frameHeaderSize);
11401 dstCapacity = dstCapacity.wrapping_sub(frameHeaderSize);
11402 cSize = cSize.wrapping_add(frameHeaderSize);
11403 let cBlocksSize = ZSTD_compressSequencesAndLiterals_internal(
11404 cctx,
11405 op as *mut core::ffi::c_void,
11406 dstCapacity,
11407 inSeqs,
11408 inSeqsSize,
11409 literals,
11410 litSize,
11411 decompressedSize,
11412 );
11413 let err_code_0 = cBlocksSize;
11414 if ERR_isError(err_code_0) {
11415 return err_code_0;
11416 }
11417 cSize = cSize.wrapping_add(cBlocksSize);
11418 dstCapacity = dstCapacity.wrapping_sub(cBlocksSize);
11419 cSize
11420}
11421unsafe fn inBuffer_forEndFlush(zcs: *const ZSTD_CStream) -> ZSTD_inBuffer {
11422 let nullInput = {
11423 ZSTD_inBuffer_s {
11424 src: core::ptr::null(),
11425 size: 0,
11426 pos: 0,
11427 }
11428 };
11429 let stableInput = ((*zcs).appliedParams.inBufferMode as core::ffi::c_uint
11430 == ZSTD_bm_stable as core::ffi::c_int as core::ffi::c_uint)
11431 as core::ffi::c_int;
11432 if stableInput != 0 {
11433 (*zcs).expectedInBuffer
11434 } else {
11435 nullInput
11436 }
11437}
11438#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_flushStream))]
11439pub unsafe extern "C" fn ZSTD_flushStream(
11440 zcs: *mut ZSTD_CStream,
11441 output: *mut ZSTD_outBuffer,
11442) -> size_t {
11443 let mut input = inBuffer_forEndFlush(zcs);
11444 input.size = input.pos;
11445 ZSTD_compressStream2(zcs, output, &mut input, ZSTD_e_flush)
11446}
11447#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_endStream))]
11448pub unsafe extern "C" fn ZSTD_endStream(
11449 zcs: *mut ZSTD_CStream,
11450 output: *mut ZSTD_outBuffer,
11451) -> size_t {
11452 let mut input = inBuffer_forEndFlush(zcs);
11453 let remainingToFlush = ZSTD_compressStream2(zcs, output, &mut input, ZSTD_e_end);
11454 let err_code = remainingToFlush;
11455 if ERR_isError(err_code) {
11456 return err_code;
11457 }
11458 if (*zcs).appliedParams.nbWorkers > 0 {
11459 return remainingToFlush;
11460 }
11461 let lastBlockSize = (if (*zcs).frameEnded != 0 {
11462 0
11463 } else {
11464 ZSTD_BLOCKHEADERSIZE
11465 }) as size_t;
11466 let checksumSize = (if (*zcs).frameEnded != 0 {
11467 0
11468 } else {
11469 (*zcs).appliedParams.fParams.checksumFlag * 4
11470 }) as size_t;
11471
11472 remainingToFlush
11473 .wrapping_add(lastBlockSize)
11474 .wrapping_add(checksumSize)
11475}
11476pub const fn ZSTD_maxCLevel() -> core::ffi::c_int {
11477 ZSTD_MAX_CLEVEL
11478}
11479#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_defaultCLevel))]
11480pub unsafe extern "C" fn ZSTD_defaultCLevel() -> core::ffi::c_int {
11481 ZSTD_CLEVEL_DEFAULT
11482}
11483unsafe fn ZSTD_dedicatedDictSearch_isSupported(
11484 cParams: *const ZSTD_compressionParameters,
11485) -> core::ffi::c_int {
11486 ((*cParams).strategy as core::ffi::c_uint
11487 >= ZSTD_greedy as core::ffi::c_int as core::ffi::c_uint
11488 && (*cParams).strategy as core::ffi::c_uint
11489 <= ZSTD_lazy2 as core::ffi::c_int as core::ffi::c_uint
11490 && (*cParams).hashLog > (*cParams).chainLog
11491 && (*cParams).chainLog <= 24) as core::ffi::c_int
11492}
11493unsafe fn ZSTD_dedicatedDictSearch_revertCParams(cParams: *mut ZSTD_compressionParameters) {
11494 if let 3..=5 = (*cParams).strategy as core::ffi::c_uint {
11495 (*cParams).hashLog =
11496 ((*cParams).hashLog).wrapping_sub(ZSTD_LAZY_DDSS_BUCKET_LOG as core::ffi::c_uint);
11497 if (*cParams).hashLog < ZSTD_HASHLOG_MIN as core::ffi::c_uint {
11498 (*cParams).hashLog = ZSTD_HASHLOG_MIN as core::ffi::c_uint;
11499 }
11500 };
11501}
11502unsafe fn ZSTD_getCParamRowSize(
11503 srcSizeHint: u64,
11504 mut dictSize: size_t,
11505 mode: ZSTD_CParamMode_e,
11506) -> u64 {
11507 if mode as core::ffi::c_uint == 1 {
11508 dictSize = 0;
11509 }
11510 let unknown =
11511 (srcSizeHint as core::ffi::c_ulonglong == ZSTD_CONTENTSIZE_UNKNOWN) as core::ffi::c_int;
11512 let addedSize = if unknown != 0 && dictSize > 0 { 500 } else { 0 };
11513 if unknown != 0 && dictSize == 0 {
11514 ZSTD_CONTENTSIZE_UNKNOWN
11515 } else {
11516 srcSizeHint
11517 .wrapping_add(dictSize as u64)
11518 .wrapping_add(addedSize)
11519 }
11520}
11521#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_getCParams))]
11522pub unsafe extern "C" fn ZSTD_getCParams(
11523 compressionLevel: core::ffi::c_int,
11524 mut srcSizeHint: core::ffi::c_ulonglong,
11525 dictSize: size_t,
11526) -> ZSTD_compressionParameters {
11527 if srcSizeHint == 0 {
11528 srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;
11529 }
11530 ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, ZSTD_cpm_unknown)
11531}
11532#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_getParams))]
11533pub unsafe extern "C" fn ZSTD_getParams(
11534 compressionLevel: core::ffi::c_int,
11535 mut srcSizeHint: core::ffi::c_ulonglong,
11536 dictSize: size_t,
11537) -> ZSTD_parameters {
11538 if srcSizeHint == 0 {
11539 srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;
11540 }
11541 ZSTD_getParams_internal(compressionLevel, srcSizeHint, dictSize, ZSTD_cpm_unknown)
11542}
11543pub const __INT_MAX__: core::ffi::c_int = 2147483647;
11544pub const ZSTD_MAX_CLEVEL: core::ffi::c_int = 22;
11545static ZSTD_defaultCParameters: [[ZSTD_compressionParameters; 23]; 4] = [
11546 [
11547 {
11548 ZSTD_compressionParameters {
11549 windowLog: 19,
11550 chainLog: 12,
11551 hashLog: 13,
11552 searchLog: 1,
11553 minMatch: 6,
11554 targetLength: 1,
11555 strategy: ZSTD_fast,
11556 }
11557 },
11558 {
11559 ZSTD_compressionParameters {
11560 windowLog: 19,
11561 chainLog: 13,
11562 hashLog: 14,
11563 searchLog: 1,
11564 minMatch: 7,
11565 targetLength: 0,
11566 strategy: ZSTD_fast,
11567 }
11568 },
11569 {
11570 ZSTD_compressionParameters {
11571 windowLog: 20,
11572 chainLog: 15,
11573 hashLog: 16,
11574 searchLog: 1,
11575 minMatch: 6,
11576 targetLength: 0,
11577 strategy: ZSTD_fast,
11578 }
11579 },
11580 {
11581 ZSTD_compressionParameters {
11582 windowLog: 21,
11583 chainLog: 16,
11584 hashLog: 17,
11585 searchLog: 1,
11586 minMatch: 5,
11587 targetLength: 0,
11588 strategy: ZSTD_dfast,
11589 }
11590 },
11591 {
11592 ZSTD_compressionParameters {
11593 windowLog: 21,
11594 chainLog: 18,
11595 hashLog: 18,
11596 searchLog: 1,
11597 minMatch: 5,
11598 targetLength: 0,
11599 strategy: ZSTD_dfast,
11600 }
11601 },
11602 {
11603 ZSTD_compressionParameters {
11604 windowLog: 21,
11605 chainLog: 18,
11606 hashLog: 19,
11607 searchLog: 3,
11608 minMatch: 5,
11609 targetLength: 2,
11610 strategy: ZSTD_greedy,
11611 }
11612 },
11613 {
11614 ZSTD_compressionParameters {
11615 windowLog: 21,
11616 chainLog: 18,
11617 hashLog: 19,
11618 searchLog: 3,
11619 minMatch: 5,
11620 targetLength: 4,
11621 strategy: ZSTD_lazy,
11622 }
11623 },
11624 {
11625 ZSTD_compressionParameters {
11626 windowLog: 21,
11627 chainLog: 19,
11628 hashLog: 20,
11629 searchLog: 4,
11630 minMatch: 5,
11631 targetLength: 8,
11632 strategy: ZSTD_lazy,
11633 }
11634 },
11635 {
11636 ZSTD_compressionParameters {
11637 windowLog: 21,
11638 chainLog: 19,
11639 hashLog: 20,
11640 searchLog: 4,
11641 minMatch: 5,
11642 targetLength: 16,
11643 strategy: ZSTD_lazy2,
11644 }
11645 },
11646 {
11647 ZSTD_compressionParameters {
11648 windowLog: 22,
11649 chainLog: 20,
11650 hashLog: 21,
11651 searchLog: 4,
11652 minMatch: 5,
11653 targetLength: 16,
11654 strategy: ZSTD_lazy2,
11655 }
11656 },
11657 {
11658 ZSTD_compressionParameters {
11659 windowLog: 22,
11660 chainLog: 21,
11661 hashLog: 22,
11662 searchLog: 5,
11663 minMatch: 5,
11664 targetLength: 16,
11665 strategy: ZSTD_lazy2,
11666 }
11667 },
11668 {
11669 ZSTD_compressionParameters {
11670 windowLog: 22,
11671 chainLog: 21,
11672 hashLog: 22,
11673 searchLog: 6,
11674 minMatch: 5,
11675 targetLength: 16,
11676 strategy: ZSTD_lazy2,
11677 }
11678 },
11679 {
11680 ZSTD_compressionParameters {
11681 windowLog: 22,
11682 chainLog: 22,
11683 hashLog: 23,
11684 searchLog: 6,
11685 minMatch: 5,
11686 targetLength: 32,
11687 strategy: ZSTD_lazy2,
11688 }
11689 },
11690 {
11691 ZSTD_compressionParameters {
11692 windowLog: 22,
11693 chainLog: 22,
11694 hashLog: 22,
11695 searchLog: 4,
11696 minMatch: 5,
11697 targetLength: 32,
11698 strategy: ZSTD_btlazy2,
11699 }
11700 },
11701 {
11702 ZSTD_compressionParameters {
11703 windowLog: 22,
11704 chainLog: 22,
11705 hashLog: 23,
11706 searchLog: 5,
11707 minMatch: 5,
11708 targetLength: 32,
11709 strategy: ZSTD_btlazy2,
11710 }
11711 },
11712 {
11713 ZSTD_compressionParameters {
11714 windowLog: 22,
11715 chainLog: 23,
11716 hashLog: 23,
11717 searchLog: 6,
11718 minMatch: 5,
11719 targetLength: 32,
11720 strategy: ZSTD_btlazy2,
11721 }
11722 },
11723 {
11724 ZSTD_compressionParameters {
11725 windowLog: 22,
11726 chainLog: 22,
11727 hashLog: 22,
11728 searchLog: 5,
11729 minMatch: 5,
11730 targetLength: 48,
11731 strategy: ZSTD_btopt,
11732 }
11733 },
11734 {
11735 ZSTD_compressionParameters {
11736 windowLog: 23,
11737 chainLog: 23,
11738 hashLog: 22,
11739 searchLog: 5,
11740 minMatch: 4,
11741 targetLength: 64,
11742 strategy: ZSTD_btopt,
11743 }
11744 },
11745 {
11746 ZSTD_compressionParameters {
11747 windowLog: 23,
11748 chainLog: 23,
11749 hashLog: 22,
11750 searchLog: 6,
11751 minMatch: 3,
11752 targetLength: 64,
11753 strategy: ZSTD_btultra,
11754 }
11755 },
11756 {
11757 ZSTD_compressionParameters {
11758 windowLog: 23,
11759 chainLog: 24,
11760 hashLog: 22,
11761 searchLog: 7,
11762 minMatch: 3,
11763 targetLength: 256,
11764 strategy: ZSTD_btultra2,
11765 }
11766 },
11767 {
11768 ZSTD_compressionParameters {
11769 windowLog: 25,
11770 chainLog: 25,
11771 hashLog: 23,
11772 searchLog: 7,
11773 minMatch: 3,
11774 targetLength: 256,
11775 strategy: ZSTD_btultra2,
11776 }
11777 },
11778 {
11779 ZSTD_compressionParameters {
11780 windowLog: 26,
11781 chainLog: 26,
11782 hashLog: 24,
11783 searchLog: 7,
11784 minMatch: 3,
11785 targetLength: 512,
11786 strategy: ZSTD_btultra2,
11787 }
11788 },
11789 {
11790 ZSTD_compressionParameters {
11791 windowLog: 27,
11792 chainLog: 27,
11793 hashLog: 25,
11794 searchLog: 9,
11795 minMatch: 3,
11796 targetLength: 999,
11797 strategy: ZSTD_btultra2,
11798 }
11799 },
11800 ],
11801 [
11802 {
11803 ZSTD_compressionParameters {
11804 windowLog: 18,
11805 chainLog: 12,
11806 hashLog: 13,
11807 searchLog: 1,
11808 minMatch: 5,
11809 targetLength: 1,
11810 strategy: ZSTD_fast,
11811 }
11812 },
11813 {
11814 ZSTD_compressionParameters {
11815 windowLog: 18,
11816 chainLog: 13,
11817 hashLog: 14,
11818 searchLog: 1,
11819 minMatch: 6,
11820 targetLength: 0,
11821 strategy: ZSTD_fast,
11822 }
11823 },
11824 {
11825 ZSTD_compressionParameters {
11826 windowLog: 18,
11827 chainLog: 14,
11828 hashLog: 14,
11829 searchLog: 1,
11830 minMatch: 5,
11831 targetLength: 0,
11832 strategy: ZSTD_dfast,
11833 }
11834 },
11835 {
11836 ZSTD_compressionParameters {
11837 windowLog: 18,
11838 chainLog: 16,
11839 hashLog: 16,
11840 searchLog: 1,
11841 minMatch: 4,
11842 targetLength: 0,
11843 strategy: ZSTD_dfast,
11844 }
11845 },
11846 {
11847 ZSTD_compressionParameters {
11848 windowLog: 18,
11849 chainLog: 16,
11850 hashLog: 17,
11851 searchLog: 3,
11852 minMatch: 5,
11853 targetLength: 2,
11854 strategy: ZSTD_greedy,
11855 }
11856 },
11857 {
11858 ZSTD_compressionParameters {
11859 windowLog: 18,
11860 chainLog: 17,
11861 hashLog: 18,
11862 searchLog: 5,
11863 minMatch: 5,
11864 targetLength: 2,
11865 strategy: ZSTD_greedy,
11866 }
11867 },
11868 {
11869 ZSTD_compressionParameters {
11870 windowLog: 18,
11871 chainLog: 18,
11872 hashLog: 19,
11873 searchLog: 3,
11874 minMatch: 5,
11875 targetLength: 4,
11876 strategy: ZSTD_lazy,
11877 }
11878 },
11879 {
11880 ZSTD_compressionParameters {
11881 windowLog: 18,
11882 chainLog: 18,
11883 hashLog: 19,
11884 searchLog: 4,
11885 minMatch: 4,
11886 targetLength: 4,
11887 strategy: ZSTD_lazy,
11888 }
11889 },
11890 {
11891 ZSTD_compressionParameters {
11892 windowLog: 18,
11893 chainLog: 18,
11894 hashLog: 19,
11895 searchLog: 4,
11896 minMatch: 4,
11897 targetLength: 8,
11898 strategy: ZSTD_lazy2,
11899 }
11900 },
11901 {
11902 ZSTD_compressionParameters {
11903 windowLog: 18,
11904 chainLog: 18,
11905 hashLog: 19,
11906 searchLog: 5,
11907 minMatch: 4,
11908 targetLength: 8,
11909 strategy: ZSTD_lazy2,
11910 }
11911 },
11912 {
11913 ZSTD_compressionParameters {
11914 windowLog: 18,
11915 chainLog: 18,
11916 hashLog: 19,
11917 searchLog: 6,
11918 minMatch: 4,
11919 targetLength: 8,
11920 strategy: ZSTD_lazy2,
11921 }
11922 },
11923 {
11924 ZSTD_compressionParameters {
11925 windowLog: 18,
11926 chainLog: 18,
11927 hashLog: 19,
11928 searchLog: 5,
11929 minMatch: 4,
11930 targetLength: 12,
11931 strategy: ZSTD_btlazy2,
11932 }
11933 },
11934 {
11935 ZSTD_compressionParameters {
11936 windowLog: 18,
11937 chainLog: 19,
11938 hashLog: 19,
11939 searchLog: 7,
11940 minMatch: 4,
11941 targetLength: 12,
11942 strategy: ZSTD_btlazy2,
11943 }
11944 },
11945 {
11946 ZSTD_compressionParameters {
11947 windowLog: 18,
11948 chainLog: 18,
11949 hashLog: 19,
11950 searchLog: 4,
11951 minMatch: 4,
11952 targetLength: 16,
11953 strategy: ZSTD_btopt,
11954 }
11955 },
11956 {
11957 ZSTD_compressionParameters {
11958 windowLog: 18,
11959 chainLog: 18,
11960 hashLog: 19,
11961 searchLog: 4,
11962 minMatch: 3,
11963 targetLength: 32,
11964 strategy: ZSTD_btopt,
11965 }
11966 },
11967 {
11968 ZSTD_compressionParameters {
11969 windowLog: 18,
11970 chainLog: 18,
11971 hashLog: 19,
11972 searchLog: 6,
11973 minMatch: 3,
11974 targetLength: 128,
11975 strategy: ZSTD_btopt,
11976 }
11977 },
11978 {
11979 ZSTD_compressionParameters {
11980 windowLog: 18,
11981 chainLog: 19,
11982 hashLog: 19,
11983 searchLog: 6,
11984 minMatch: 3,
11985 targetLength: 128,
11986 strategy: ZSTD_btultra,
11987 }
11988 },
11989 {
11990 ZSTD_compressionParameters {
11991 windowLog: 18,
11992 chainLog: 19,
11993 hashLog: 19,
11994 searchLog: 8,
11995 minMatch: 3,
11996 targetLength: 256,
11997 strategy: ZSTD_btultra,
11998 }
11999 },
12000 {
12001 ZSTD_compressionParameters {
12002 windowLog: 18,
12003 chainLog: 19,
12004 hashLog: 19,
12005 searchLog: 6,
12006 minMatch: 3,
12007 targetLength: 128,
12008 strategy: ZSTD_btultra2,
12009 }
12010 },
12011 {
12012 ZSTD_compressionParameters {
12013 windowLog: 18,
12014 chainLog: 19,
12015 hashLog: 19,
12016 searchLog: 8,
12017 minMatch: 3,
12018 targetLength: 256,
12019 strategy: ZSTD_btultra2,
12020 }
12021 },
12022 {
12023 ZSTD_compressionParameters {
12024 windowLog: 18,
12025 chainLog: 19,
12026 hashLog: 19,
12027 searchLog: 10,
12028 minMatch: 3,
12029 targetLength: 512,
12030 strategy: ZSTD_btultra2,
12031 }
12032 },
12033 {
12034 ZSTD_compressionParameters {
12035 windowLog: 18,
12036 chainLog: 19,
12037 hashLog: 19,
12038 searchLog: 12,
12039 minMatch: 3,
12040 targetLength: 512,
12041 strategy: ZSTD_btultra2,
12042 }
12043 },
12044 {
12045 ZSTD_compressionParameters {
12046 windowLog: 18,
12047 chainLog: 19,
12048 hashLog: 19,
12049 searchLog: 13,
12050 minMatch: 3,
12051 targetLength: 999,
12052 strategy: ZSTD_btultra2,
12053 }
12054 },
12055 ],
12056 [
12057 {
12058 ZSTD_compressionParameters {
12059 windowLog: 17,
12060 chainLog: 12,
12061 hashLog: 12,
12062 searchLog: 1,
12063 minMatch: 5,
12064 targetLength: 1,
12065 strategy: ZSTD_fast,
12066 }
12067 },
12068 {
12069 ZSTD_compressionParameters {
12070 windowLog: 17,
12071 chainLog: 12,
12072 hashLog: 13,
12073 searchLog: 1,
12074 minMatch: 6,
12075 targetLength: 0,
12076 strategy: ZSTD_fast,
12077 }
12078 },
12079 {
12080 ZSTD_compressionParameters {
12081 windowLog: 17,
12082 chainLog: 13,
12083 hashLog: 15,
12084 searchLog: 1,
12085 minMatch: 5,
12086 targetLength: 0,
12087 strategy: ZSTD_fast,
12088 }
12089 },
12090 {
12091 ZSTD_compressionParameters {
12092 windowLog: 17,
12093 chainLog: 15,
12094 hashLog: 16,
12095 searchLog: 2,
12096 minMatch: 5,
12097 targetLength: 0,
12098 strategy: ZSTD_dfast,
12099 }
12100 },
12101 {
12102 ZSTD_compressionParameters {
12103 windowLog: 17,
12104 chainLog: 17,
12105 hashLog: 17,
12106 searchLog: 2,
12107 minMatch: 4,
12108 targetLength: 0,
12109 strategy: ZSTD_dfast,
12110 }
12111 },
12112 {
12113 ZSTD_compressionParameters {
12114 windowLog: 17,
12115 chainLog: 16,
12116 hashLog: 17,
12117 searchLog: 3,
12118 minMatch: 4,
12119 targetLength: 2,
12120 strategy: ZSTD_greedy,
12121 }
12122 },
12123 {
12124 ZSTD_compressionParameters {
12125 windowLog: 17,
12126 chainLog: 16,
12127 hashLog: 17,
12128 searchLog: 3,
12129 minMatch: 4,
12130 targetLength: 4,
12131 strategy: ZSTD_lazy,
12132 }
12133 },
12134 {
12135 ZSTD_compressionParameters {
12136 windowLog: 17,
12137 chainLog: 16,
12138 hashLog: 17,
12139 searchLog: 3,
12140 minMatch: 4,
12141 targetLength: 8,
12142 strategy: ZSTD_lazy2,
12143 }
12144 },
12145 {
12146 ZSTD_compressionParameters {
12147 windowLog: 17,
12148 chainLog: 16,
12149 hashLog: 17,
12150 searchLog: 4,
12151 minMatch: 4,
12152 targetLength: 8,
12153 strategy: ZSTD_lazy2,
12154 }
12155 },
12156 {
12157 ZSTD_compressionParameters {
12158 windowLog: 17,
12159 chainLog: 16,
12160 hashLog: 17,
12161 searchLog: 5,
12162 minMatch: 4,
12163 targetLength: 8,
12164 strategy: ZSTD_lazy2,
12165 }
12166 },
12167 {
12168 ZSTD_compressionParameters {
12169 windowLog: 17,
12170 chainLog: 16,
12171 hashLog: 17,
12172 searchLog: 6,
12173 minMatch: 4,
12174 targetLength: 8,
12175 strategy: ZSTD_lazy2,
12176 }
12177 },
12178 {
12179 ZSTD_compressionParameters {
12180 windowLog: 17,
12181 chainLog: 17,
12182 hashLog: 17,
12183 searchLog: 5,
12184 minMatch: 4,
12185 targetLength: 8,
12186 strategy: ZSTD_btlazy2,
12187 }
12188 },
12189 {
12190 ZSTD_compressionParameters {
12191 windowLog: 17,
12192 chainLog: 18,
12193 hashLog: 17,
12194 searchLog: 7,
12195 minMatch: 4,
12196 targetLength: 12,
12197 strategy: ZSTD_btlazy2,
12198 }
12199 },
12200 {
12201 ZSTD_compressionParameters {
12202 windowLog: 17,
12203 chainLog: 18,
12204 hashLog: 17,
12205 searchLog: 3,
12206 minMatch: 4,
12207 targetLength: 12,
12208 strategy: ZSTD_btopt,
12209 }
12210 },
12211 {
12212 ZSTD_compressionParameters {
12213 windowLog: 17,
12214 chainLog: 18,
12215 hashLog: 17,
12216 searchLog: 4,
12217 minMatch: 3,
12218 targetLength: 32,
12219 strategy: ZSTD_btopt,
12220 }
12221 },
12222 {
12223 ZSTD_compressionParameters {
12224 windowLog: 17,
12225 chainLog: 18,
12226 hashLog: 17,
12227 searchLog: 6,
12228 minMatch: 3,
12229 targetLength: 256,
12230 strategy: ZSTD_btopt,
12231 }
12232 },
12233 {
12234 ZSTD_compressionParameters {
12235 windowLog: 17,
12236 chainLog: 18,
12237 hashLog: 17,
12238 searchLog: 6,
12239 minMatch: 3,
12240 targetLength: 128,
12241 strategy: ZSTD_btultra,
12242 }
12243 },
12244 {
12245 ZSTD_compressionParameters {
12246 windowLog: 17,
12247 chainLog: 18,
12248 hashLog: 17,
12249 searchLog: 8,
12250 minMatch: 3,
12251 targetLength: 256,
12252 strategy: ZSTD_btultra,
12253 }
12254 },
12255 {
12256 ZSTD_compressionParameters {
12257 windowLog: 17,
12258 chainLog: 18,
12259 hashLog: 17,
12260 searchLog: 10,
12261 minMatch: 3,
12262 targetLength: 512,
12263 strategy: ZSTD_btultra,
12264 }
12265 },
12266 {
12267 ZSTD_compressionParameters {
12268 windowLog: 17,
12269 chainLog: 18,
12270 hashLog: 17,
12271 searchLog: 5,
12272 minMatch: 3,
12273 targetLength: 256,
12274 strategy: ZSTD_btultra2,
12275 }
12276 },
12277 {
12278 ZSTD_compressionParameters {
12279 windowLog: 17,
12280 chainLog: 18,
12281 hashLog: 17,
12282 searchLog: 7,
12283 minMatch: 3,
12284 targetLength: 512,
12285 strategy: ZSTD_btultra2,
12286 }
12287 },
12288 {
12289 ZSTD_compressionParameters {
12290 windowLog: 17,
12291 chainLog: 18,
12292 hashLog: 17,
12293 searchLog: 9,
12294 minMatch: 3,
12295 targetLength: 512,
12296 strategy: ZSTD_btultra2,
12297 }
12298 },
12299 {
12300 ZSTD_compressionParameters {
12301 windowLog: 17,
12302 chainLog: 18,
12303 hashLog: 17,
12304 searchLog: 11,
12305 minMatch: 3,
12306 targetLength: 999,
12307 strategy: ZSTD_btultra2,
12308 }
12309 },
12310 ],
12311 [
12312 {
12313 ZSTD_compressionParameters {
12314 windowLog: 14,
12315 chainLog: 12,
12316 hashLog: 13,
12317 searchLog: 1,
12318 minMatch: 5,
12319 targetLength: 1,
12320 strategy: ZSTD_fast,
12321 }
12322 },
12323 {
12324 ZSTD_compressionParameters {
12325 windowLog: 14,
12326 chainLog: 14,
12327 hashLog: 15,
12328 searchLog: 1,
12329 minMatch: 5,
12330 targetLength: 0,
12331 strategy: ZSTD_fast,
12332 }
12333 },
12334 {
12335 ZSTD_compressionParameters {
12336 windowLog: 14,
12337 chainLog: 14,
12338 hashLog: 15,
12339 searchLog: 1,
12340 minMatch: 4,
12341 targetLength: 0,
12342 strategy: ZSTD_fast,
12343 }
12344 },
12345 {
12346 ZSTD_compressionParameters {
12347 windowLog: 14,
12348 chainLog: 14,
12349 hashLog: 15,
12350 searchLog: 2,
12351 minMatch: 4,
12352 targetLength: 0,
12353 strategy: ZSTD_dfast,
12354 }
12355 },
12356 {
12357 ZSTD_compressionParameters {
12358 windowLog: 14,
12359 chainLog: 14,
12360 hashLog: 14,
12361 searchLog: 4,
12362 minMatch: 4,
12363 targetLength: 2,
12364 strategy: ZSTD_greedy,
12365 }
12366 },
12367 {
12368 ZSTD_compressionParameters {
12369 windowLog: 14,
12370 chainLog: 14,
12371 hashLog: 14,
12372 searchLog: 3,
12373 minMatch: 4,
12374 targetLength: 4,
12375 strategy: ZSTD_lazy,
12376 }
12377 },
12378 {
12379 ZSTD_compressionParameters {
12380 windowLog: 14,
12381 chainLog: 14,
12382 hashLog: 14,
12383 searchLog: 4,
12384 minMatch: 4,
12385 targetLength: 8,
12386 strategy: ZSTD_lazy2,
12387 }
12388 },
12389 {
12390 ZSTD_compressionParameters {
12391 windowLog: 14,
12392 chainLog: 14,
12393 hashLog: 14,
12394 searchLog: 6,
12395 minMatch: 4,
12396 targetLength: 8,
12397 strategy: ZSTD_lazy2,
12398 }
12399 },
12400 {
12401 ZSTD_compressionParameters {
12402 windowLog: 14,
12403 chainLog: 14,
12404 hashLog: 14,
12405 searchLog: 8,
12406 minMatch: 4,
12407 targetLength: 8,
12408 strategy: ZSTD_lazy2,
12409 }
12410 },
12411 {
12412 ZSTD_compressionParameters {
12413 windowLog: 14,
12414 chainLog: 15,
12415 hashLog: 14,
12416 searchLog: 5,
12417 minMatch: 4,
12418 targetLength: 8,
12419 strategy: ZSTD_btlazy2,
12420 }
12421 },
12422 {
12423 ZSTD_compressionParameters {
12424 windowLog: 14,
12425 chainLog: 15,
12426 hashLog: 14,
12427 searchLog: 9,
12428 minMatch: 4,
12429 targetLength: 8,
12430 strategy: ZSTD_btlazy2,
12431 }
12432 },
12433 {
12434 ZSTD_compressionParameters {
12435 windowLog: 14,
12436 chainLog: 15,
12437 hashLog: 14,
12438 searchLog: 3,
12439 minMatch: 4,
12440 targetLength: 12,
12441 strategy: ZSTD_btopt,
12442 }
12443 },
12444 {
12445 ZSTD_compressionParameters {
12446 windowLog: 14,
12447 chainLog: 15,
12448 hashLog: 14,
12449 searchLog: 4,
12450 minMatch: 3,
12451 targetLength: 24,
12452 strategy: ZSTD_btopt,
12453 }
12454 },
12455 {
12456 ZSTD_compressionParameters {
12457 windowLog: 14,
12458 chainLog: 15,
12459 hashLog: 14,
12460 searchLog: 5,
12461 minMatch: 3,
12462 targetLength: 32,
12463 strategy: ZSTD_btultra,
12464 }
12465 },
12466 {
12467 ZSTD_compressionParameters {
12468 windowLog: 14,
12469 chainLog: 15,
12470 hashLog: 15,
12471 searchLog: 6,
12472 minMatch: 3,
12473 targetLength: 64,
12474 strategy: ZSTD_btultra,
12475 }
12476 },
12477 {
12478 ZSTD_compressionParameters {
12479 windowLog: 14,
12480 chainLog: 15,
12481 hashLog: 15,
12482 searchLog: 7,
12483 minMatch: 3,
12484 targetLength: 256,
12485 strategy: ZSTD_btultra,
12486 }
12487 },
12488 {
12489 ZSTD_compressionParameters {
12490 windowLog: 14,
12491 chainLog: 15,
12492 hashLog: 15,
12493 searchLog: 5,
12494 minMatch: 3,
12495 targetLength: 48,
12496 strategy: ZSTD_btultra2,
12497 }
12498 },
12499 {
12500 ZSTD_compressionParameters {
12501 windowLog: 14,
12502 chainLog: 15,
12503 hashLog: 15,
12504 searchLog: 6,
12505 minMatch: 3,
12506 targetLength: 128,
12507 strategy: ZSTD_btultra2,
12508 }
12509 },
12510 {
12511 ZSTD_compressionParameters {
12512 windowLog: 14,
12513 chainLog: 15,
12514 hashLog: 15,
12515 searchLog: 7,
12516 minMatch: 3,
12517 targetLength: 256,
12518 strategy: ZSTD_btultra2,
12519 }
12520 },
12521 {
12522 ZSTD_compressionParameters {
12523 windowLog: 14,
12524 chainLog: 15,
12525 hashLog: 15,
12526 searchLog: 8,
12527 minMatch: 3,
12528 targetLength: 256,
12529 strategy: ZSTD_btultra2,
12530 }
12531 },
12532 {
12533 ZSTD_compressionParameters {
12534 windowLog: 14,
12535 chainLog: 15,
12536 hashLog: 15,
12537 searchLog: 8,
12538 minMatch: 3,
12539 targetLength: 512,
12540 strategy: ZSTD_btultra2,
12541 }
12542 },
12543 {
12544 ZSTD_compressionParameters {
12545 windowLog: 14,
12546 chainLog: 15,
12547 hashLog: 15,
12548 searchLog: 9,
12549 minMatch: 3,
12550 targetLength: 512,
12551 strategy: ZSTD_btultra2,
12552 }
12553 },
12554 {
12555 ZSTD_compressionParameters {
12556 windowLog: 14,
12557 chainLog: 15,
12558 hashLog: 15,
12559 searchLog: 10,
12560 minMatch: 3,
12561 targetLength: 999,
12562 strategy: ZSTD_btultra2,
12563 }
12564 },
12565 ],
12566];
12567
12568pub const fn ZSTD_minCLevel() -> core::ffi::c_int {
12569 -ZSTD_TARGETLENGTH_MAX
12570}
12571unsafe fn ZSTD_dedicatedDictSearch_getCParams(
12572 compressionLevel: core::ffi::c_int,
12573 dictSize: size_t,
12574) -> ZSTD_compressionParameters {
12575 let mut cParams = ZSTD_getCParams_internal(compressionLevel, 0, dictSize, ZSTD_cpm_createCDict);
12576 if let 3..=5 = cParams.strategy as core::ffi::c_uint {
12577 cParams.hashLog =
12578 (cParams.hashLog).wrapping_add(ZSTD_LAZY_DDSS_BUCKET_LOG as core::ffi::c_uint);
12579 }
12580 cParams
12581}
12582unsafe fn ZSTD_getCParams_internal(
12583 compressionLevel: core::ffi::c_int,
12584 srcSizeHint: core::ffi::c_ulonglong,
12585 dictSize: size_t,
12586 mode: ZSTD_CParamMode_e,
12587) -> ZSTD_compressionParameters {
12588 let rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
12589 let tableID = ((rSize <= (256 * ((1) << 10)) as u64) as core::ffi::c_int
12590 + (rSize <= (128 * ((1) << 10)) as u64) as core::ffi::c_int
12591 + (rSize <= (16 * ((1) << 10)) as u64) as core::ffi::c_int) as u32;
12592 let mut row: core::ffi::c_int = 0;
12593 if compressionLevel == 0 {
12594 row = ZSTD_CLEVEL_DEFAULT;
12595 } else if compressionLevel < 0 {
12596 row = 0;
12597 } else if compressionLevel > ZSTD_MAX_CLEVEL {
12598 row = ZSTD_MAX_CLEVEL;
12599 } else {
12600 row = compressionLevel;
12601 }
12602 let mut cp = *(*ZSTD_defaultCParameters.as_ptr().offset(tableID as isize))
12603 .as_ptr()
12604 .offset(row as isize);
12605 if compressionLevel < 0 {
12606 let clampedCompressionLevel = if ZSTD_minCLevel() > compressionLevel {
12607 ZSTD_minCLevel()
12608 } else {
12609 compressionLevel
12610 };
12611 cp.targetLength = -clampedCompressionLevel as core::ffi::c_uint;
12612 }
12613 ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto)
12614}
12615unsafe fn ZSTD_getParams_internal(
12616 compressionLevel: core::ffi::c_int,
12617 srcSizeHint: core::ffi::c_ulonglong,
12618 dictSize: size_t,
12619 mode: ZSTD_CParamMode_e,
12620) -> ZSTD_parameters {
12621 let mut params = ZSTD_parameters {
12622 cParams: ZSTD_compressionParameters {
12623 windowLog: 0,
12624 chainLog: 0,
12625 hashLog: 0,
12626 searchLog: 0,
12627 minMatch: 0,
12628 targetLength: 0,
12629 strategy: 0,
12630 },
12631 fParams: ZSTD_frameParameters {
12632 contentSizeFlag: 0,
12633 checksumFlag: 0,
12634 noDictIDFlag: 0,
12635 },
12636 };
12637 let cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
12638 ptr::write_bytes(
12639 &mut params as *mut ZSTD_parameters as *mut u8,
12640 0,
12641 ::core::mem::size_of::<ZSTD_parameters>(),
12642 );
12643 params.cParams = cParams;
12644 params.fParams.contentSizeFlag = 1;
12645 params
12646}
12647#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_registerSequenceProducer))]
12648pub unsafe extern "C" fn ZSTD_registerSequenceProducer(
12649 zc: *mut ZSTD_CCtx,
12650 extSeqProdState: *mut core::ffi::c_void,
12651 extSeqProdFunc: ZSTD_sequenceProducer_F,
12652) {
12653 ZSTD_CCtxParams_registerSequenceProducer(
12654 &mut (*zc).requestedParams,
12655 extSeqProdState,
12656 extSeqProdFunc,
12657 );
12658}
12659#[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_CCtxParams_registerSequenceProducer))]
12660pub unsafe extern "C" fn ZSTD_CCtxParams_registerSequenceProducer(
12661 params: *mut ZSTD_CCtx_params,
12662 extSeqProdState: *mut core::ffi::c_void,
12663 extSeqProdFunc: ZSTD_sequenceProducer_F,
12664) {
12665 if extSeqProdFunc.is_some() {
12666 (*params).extSeqProdFunc = extSeqProdFunc;
12667 (*params).extSeqProdState = extSeqProdState;
12668 } else {
12669 (*params).extSeqProdFunc = None;
12670 (*params).extSeqProdState = core::ptr::null_mut();
12671 };
12672}