1use libc::size_t;
2
3use crate::lib::common::bitstream::{
4 BIT_CStream_t, BIT_addBits, BIT_closeCStream, BIT_flushBits, BIT_initCStream, BitContainerType,
5};
6use crate::lib::common::error_private::{ERR_isError, Error};
7use crate::lib::common::fse::{
8 FSE_CState_t, FSE_CTable, FSE_bitCost, FSE_encodeSymbol, FSE_flushCState, FSE_initCState,
9 FSE_initCState2, FSE_repeat, FSE_repeat_check, FSE_repeat_none, FSE_repeat_valid,
10};
11use crate::lib::common::mem::{MEM_32bits, MEM_read16};
12use crate::lib::common::zstd_internal::{LLFSELog, LL_bits, MLFSELog, ML_bits, OffFSELog};
13use crate::lib::compress::fse_compress::{
14 FSE_buildCTable_rle, FSE_buildCTable_wksp, FSE_normalizeCount, FSE_optimalTableLog,
15 FSE_writeNCount,
16};
17use crate::lib::compress::zstd_compress::SeqDef;
18use crate::lib::zstd::*;
19
20pub type SymbolEncodingType_e = core::ffi::c_uint;
21pub const set_repeat: SymbolEncodingType_e = 3;
22pub const set_compressed: SymbolEncodingType_e = 2;
23pub const set_rle: SymbolEncodingType_e = 1;
24pub const set_basic: SymbolEncodingType_e = 0;
25pub type ZSTD_DefaultPolicy_e = core::ffi::c_uint;
26pub const ZSTD_defaultAllowed: ZSTD_DefaultPolicy_e = 1;
27pub const ZSTD_defaultDisallowed: ZSTD_DefaultPolicy_e = 0;
28#[derive(Copy, Clone)]
29#[repr(C)]
30pub struct ZSTD_BuildCTableWksp {
31 pub norm: [i16; 53],
32 pub wksp: [u32; 285],
33}
34static kInverseProbabilityLog256: [core::ffi::c_uint; 256] = [
35 0, 2048, 1792, 1642, 1536, 1453, 1386, 1329, 1280, 1236, 1197, 1162, 1130, 1100, 1073, 1047,
36 1024, 1001, 980, 960, 941, 923, 906, 889, 874, 859, 844, 830, 817, 804, 791, 779, 768, 756,
37 745, 734, 724, 714, 704, 694, 685, 676, 667, 658, 650, 642, 633, 626, 618, 610, 603, 595, 588,
38 581, 574, 567, 561, 554, 548, 542, 535, 529, 523, 517, 512, 506, 500, 495, 489, 484, 478, 473,
39 468, 463, 458, 453, 448, 443, 438, 434, 429, 424, 420, 415, 411, 407, 402, 398, 394, 390, 386,
40 382, 377, 373, 370, 366, 362, 358, 354, 350, 347, 343, 339, 336, 332, 329, 325, 322, 318, 315,
41 311, 308, 305, 302, 298, 295, 292, 289, 286, 282, 279, 276, 273, 270, 267, 264, 261, 258, 256,
42 253, 250, 247, 244, 241, 239, 236, 233, 230, 228, 225, 222, 220, 217, 215, 212, 209, 207, 204,
43 202, 199, 197, 194, 192, 190, 187, 185, 182, 180, 178, 175, 173, 171, 168, 166, 164, 162, 159,
44 157, 155, 153, 151, 149, 146, 144, 142, 140, 138, 136, 134, 132, 130, 128, 126, 123, 121, 119,
45 117, 115, 114, 112, 110, 108, 106, 104, 102, 100, 98, 96, 94, 93, 91, 89, 87, 85, 83, 82, 80,
46 78, 76, 74, 73, 71, 69, 67, 66, 64, 62, 61, 59, 57, 55, 54, 52, 50, 49, 47, 46, 44, 42, 41, 39,
47 37, 36, 34, 33, 31, 30, 28, 26, 25, 23, 22, 20, 19, 17, 16, 14, 13, 11, 10, 8, 7, 5, 4, 2, 1,
48];
49unsafe fn ZSTD_getFSEMaxSymbolValue(ctable: *const FSE_CTable) -> core::ffi::c_uint {
50 let ptr = ctable as *const core::ffi::c_void;
51 let u16ptr = ptr as *const u16;
52
53 MEM_read16(u16ptr.offset(1) as *const core::ffi::c_void) as u32
54}
55unsafe fn ZSTD_useLowProbCount(nbSeq: size_t) -> core::ffi::c_uint {
56 (nbSeq >= 2048) as core::ffi::c_int as core::ffi::c_uint
57}
58unsafe fn ZSTD_NCountCost(
59 count: *const core::ffi::c_uint,
60 max: core::ffi::c_uint,
61 nbSeq: size_t,
62 FSELog: core::ffi::c_uint,
63) -> size_t {
64 let mut wksp: [u8; 512] = [0; 512];
65 let mut norm: [i16; 53] = [0; 53];
66 let tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
67 let err_code = FSE_normalizeCount(
68 norm.as_mut_ptr(),
69 tableLog,
70 count,
71 nbSeq,
72 max,
73 ZSTD_useLowProbCount(nbSeq),
74 );
75 if ERR_isError(err_code) {
76 return err_code;
77 }
78 FSE_writeNCount(
79 wksp.as_mut_ptr() as *mut core::ffi::c_void,
80 ::core::mem::size_of::<[u8; 512]>(),
81 norm.as_mut_ptr(),
82 max,
83 tableLog,
84 )
85}
86unsafe fn ZSTD_entropyCost(
87 count: *const core::ffi::c_uint,
88 max: core::ffi::c_uint,
89 total: size_t,
90) -> size_t {
91 let mut cost = 0 as core::ffi::c_uint;
92 let mut s: core::ffi::c_uint = 0;
93 s = 0;
94 while s <= max {
95 let mut norm = ((256 as core::ffi::c_uint).wrapping_mul(*count.offset(s as isize))
96 as size_t
97 / total) as core::ffi::c_uint;
98 if *count.offset(s as isize) != 0 && norm == 0 {
99 norm = 1;
100 }
101 cost = cost.wrapping_add(
102 (*count.offset(s as isize))
103 .wrapping_mul(*kInverseProbabilityLog256.as_ptr().offset(norm as isize)),
104 );
105 s = s.wrapping_add(1);
106 }
107 (cost >> 8) as size_t
108}
109pub unsafe fn ZSTD_fseBitCost(
110 ctable: *const FSE_CTable,
111 count: *const core::ffi::c_uint,
112 max: core::ffi::c_uint,
113) -> size_t {
114 let kAccuracyLog = 8;
115 let mut cost = 0 as size_t;
116 let mut s: core::ffi::c_uint = 0;
117 let mut cstate = FSE_CState_t {
118 value: 0,
119 stateTable: core::ptr::null::<core::ffi::c_void>(),
120 symbolTT: core::ptr::null::<core::ffi::c_void>(),
121 stateLog: 0,
122 };
123 FSE_initCState(&mut cstate, ctable);
124 if ZSTD_getFSEMaxSymbolValue(ctable) < max {
125 return Error::GENERIC.to_error_code();
126 }
127 s = 0;
128 while s <= max {
129 let tableLog = cstate.stateLog;
130 let badCost = tableLog.wrapping_add(1) << kAccuracyLog;
131 let bitCost = FSE_bitCost(cstate.symbolTT, tableLog, s, kAccuracyLog);
132 if *count.offset(s as isize) != 0 {
133 if bitCost >= badCost {
134 return Error::GENERIC.to_error_code();
135 }
136 cost = cost.wrapping_add(*count.offset(s as isize) as size_t * bitCost as size_t);
137 }
138 s = s.wrapping_add(1);
139 }
140 cost >> kAccuracyLog
141}
142pub unsafe fn ZSTD_crossEntropyCost(
143 norm: *const core::ffi::c_short,
144 accuracyLog: core::ffi::c_uint,
145 count: *const core::ffi::c_uint,
146 max: core::ffi::c_uint,
147) -> size_t {
148 let shift = (8 as core::ffi::c_uint).wrapping_sub(accuracyLog);
149 let mut cost = 0 as size_t;
150 let mut s: core::ffi::c_uint = 0;
151 s = 0;
152 while s <= max {
153 let normAcc = if *norm.offset(s as isize) as core::ffi::c_int != -(1) {
154 *norm.offset(s as isize) as core::ffi::c_uint
155 } else {
156 1
157 };
158 let norm256 = normAcc << shift;
159 cost = cost.wrapping_add(
160 (*count.offset(s as isize))
161 .wrapping_mul(*kInverseProbabilityLog256.as_ptr().offset(norm256 as isize))
162 as size_t,
163 );
164 s = s.wrapping_add(1);
165 }
166 cost >> 8
167}
168pub unsafe fn ZSTD_selectEncodingType(
169 repeatMode: *mut FSE_repeat,
170 count: *const core::ffi::c_uint,
171 max: core::ffi::c_uint,
172 mostFrequent: size_t,
173 nbSeq: size_t,
174 FSELog: core::ffi::c_uint,
175 prevCTable: *const FSE_CTable,
176 defaultNorm: *const core::ffi::c_short,
177 defaultNormLog: u32,
178 isDefaultAllowed: ZSTD_DefaultPolicy_e,
179 strategy: ZSTD_strategy,
180) -> SymbolEncodingType_e {
181 if mostFrequent == nbSeq {
182 *repeatMode = FSE_repeat_none;
183 if isDefaultAllowed as core::ffi::c_uint != 0 && nbSeq <= 2 {
184 return set_basic;
185 }
186 return set_rle;
187 }
188 if (strategy as core::ffi::c_uint) < ZSTD_lazy as core::ffi::c_int as core::ffi::c_uint {
189 if isDefaultAllowed as u64 != 0 {
190 let staticFse_nbSeq_max = 1000;
191 let mult =
192 (10 as core::ffi::c_uint).wrapping_sub(strategy as core::ffi::c_uint) as size_t;
193 let baseLog = 3;
194 let dynamicFse_nbSeq_min = (((1) << defaultNormLog) * mult) >> baseLog;
195 if *repeatMode as core::ffi::c_uint
196 == FSE_repeat_valid as core::ffi::c_int as core::ffi::c_uint
197 && nbSeq < staticFse_nbSeq_max
198 {
199 return set_repeat;
200 }
201 if nbSeq < dynamicFse_nbSeq_min
202 || mostFrequent < nbSeq >> defaultNormLog.wrapping_sub(1)
203 {
204 *repeatMode = FSE_repeat_none;
205 return set_basic;
206 }
207 }
208 } else {
209 let basicCost = if isDefaultAllowed as core::ffi::c_uint != 0 {
210 ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, count, max)
211 } else {
212 Error::GENERIC.to_error_code()
213 };
214 let repeatCost = if *repeatMode as core::ffi::c_uint
215 != FSE_repeat_none as core::ffi::c_int as core::ffi::c_uint
216 {
217 ZSTD_fseBitCost(prevCTable, count, max)
218 } else {
219 Error::GENERIC.to_error_code()
220 };
221 let NCountCost = ZSTD_NCountCost(count, max, nbSeq, FSELog);
222 let compressedCost = (NCountCost << 3).wrapping_add(ZSTD_entropyCost(count, max, nbSeq));
223 isDefaultAllowed as u64 != 0;
224 if basicCost <= repeatCost && basicCost <= compressedCost {
225 *repeatMode = FSE_repeat_none;
226 return set_basic;
227 }
228 if repeatCost <= compressedCost {
229 return set_repeat;
230 }
231 }
232 *repeatMode = FSE_repeat_check;
233 set_compressed
234}
235pub unsafe fn ZSTD_buildCTable(
236 dst: *mut core::ffi::c_void,
237 dstCapacity: size_t,
238 nextCTable: *mut FSE_CTable,
239 FSELog: u32,
240 type_0: SymbolEncodingType_e,
241 count: *mut core::ffi::c_uint,
242 max: u32,
243 codeTable: *const u8,
244 nbSeq: size_t,
245 defaultNorm: *const i16,
246 defaultNormLog: u32,
247 defaultMax: u32,
248 prevCTable: *const FSE_CTable,
249 prevCTableSize: size_t,
250 entropyWorkspace: *mut core::ffi::c_void,
251 entropyWorkspaceSize: size_t,
252) -> size_t {
253 let op = dst as *mut u8;
254 let oend: *const u8 = op.add(dstCapacity);
255 match type_0 as core::ffi::c_uint {
256 1 => {
257 let err_code = FSE_buildCTable_rle(nextCTable, max as u8);
258 if ERR_isError(err_code) {
259 return err_code;
260 }
261 if dstCapacity == 0 {
262 return Error::dstSize_tooSmall.to_error_code();
263 }
264 *op = *codeTable.offset(0);
265 1
266 }
267 3 => {
268 libc::memcpy(
269 nextCTable as *mut core::ffi::c_void,
270 prevCTable as *const core::ffi::c_void,
271 prevCTableSize as libc::size_t,
272 );
273 0
274 }
275 0 => {
276 let err_code_0 = FSE_buildCTable_wksp(
277 nextCTable,
278 defaultNorm,
279 defaultMax,
280 defaultNormLog,
281 entropyWorkspace,
282 entropyWorkspaceSize,
283 );
284 if ERR_isError(err_code_0) {
285 return err_code_0;
286 }
287 0
288 }
289 2 => {
290 let wksp = entropyWorkspace as *mut ZSTD_BuildCTableWksp;
291 let mut nbSeq_1 = nbSeq;
292 let tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
293 if *count.offset(*codeTable.add(nbSeq.wrapping_sub(1)) as isize) > 1 {
294 let fresh0 = &mut (*count.offset(*codeTable.add(nbSeq.wrapping_sub(1)) as isize));
295 *fresh0 = (*fresh0).wrapping_sub(1);
296 nbSeq_1 = nbSeq_1.wrapping_sub(1);
297 }
298 let err_code_1 = FSE_normalizeCount(
299 ((*wksp).norm).as_mut_ptr(),
300 tableLog,
301 count,
302 nbSeq_1,
303 max,
304 ZSTD_useLowProbCount(nbSeq_1),
305 );
306 if ERR_isError(err_code_1) {
307 return err_code_1;
308 }
309 let NCountSize = FSE_writeNCount(
310 op as *mut core::ffi::c_void,
311 oend.offset_from(op) as size_t,
312 ((*wksp).norm).as_mut_ptr(),
313 max,
314 tableLog,
315 );
316 let err_code_2 = NCountSize;
317 if ERR_isError(err_code_2) {
318 return err_code_2;
319 }
320 let err_code_3 = FSE_buildCTable_wksp(
321 nextCTable,
322 ((*wksp).norm).as_mut_ptr(),
323 max,
324 tableLog,
325 ((*wksp).wksp).as_mut_ptr() as *mut core::ffi::c_void,
326 ::core::mem::size_of::<[u32; 285]>(),
327 );
328 if ERR_isError(err_code_3) {
329 return err_code_3;
330 }
331 NCountSize
332 }
333 _ => Error::GENERIC.to_error_code(),
334 }
335}
336unsafe fn ZSTD_encodeSequences_body(
337 dst: *mut core::ffi::c_void,
338 dstCapacity: size_t,
339 CTable_MatchLength: *const FSE_CTable,
340 mlCodeTable: *const u8,
341 CTable_OffsetBits: *const FSE_CTable,
342 ofCodeTable: *const u8,
343 CTable_LitLength: *const FSE_CTable,
344 llCodeTable: *const u8,
345 sequences: *const SeqDef,
346 nbSeq: size_t,
347 longOffsets: core::ffi::c_int,
348) -> size_t {
349 let mut blockStream = BIT_CStream_t {
350 bitContainer: 0,
351 bitPos: 0,
352 startPtr: core::ptr::null_mut::<core::ffi::c_char>(),
353 ptr: core::ptr::null_mut::<core::ffi::c_char>(),
354 endPtr: core::ptr::null_mut::<core::ffi::c_char>(),
355 };
356 let mut stateMatchLength = FSE_CState_t {
357 value: 0,
358 stateTable: core::ptr::null::<core::ffi::c_void>(),
359 symbolTT: core::ptr::null::<core::ffi::c_void>(),
360 stateLog: 0,
361 };
362 let mut stateOffsetBits = FSE_CState_t {
363 value: 0,
364 stateTable: core::ptr::null::<core::ffi::c_void>(),
365 symbolTT: core::ptr::null::<core::ffi::c_void>(),
366 stateLog: 0,
367 };
368 let mut stateLitLength = FSE_CState_t {
369 value: 0,
370 stateTable: core::ptr::null::<core::ffi::c_void>(),
371 symbolTT: core::ptr::null::<core::ffi::c_void>(),
372 stateLog: 0,
373 };
374 if ERR_isError(BIT_initCStream(&mut blockStream, dst, dstCapacity)) {
375 return Error::dstSize_tooSmall.to_error_code();
376 }
377 FSE_initCState2(
378 &mut stateMatchLength,
379 CTable_MatchLength,
380 *mlCodeTable.add(nbSeq.wrapping_sub(1)) as u32,
381 );
382 FSE_initCState2(
383 &mut stateOffsetBits,
384 CTable_OffsetBits,
385 *ofCodeTable.add(nbSeq.wrapping_sub(1)) as u32,
386 );
387 FSE_initCState2(
388 &mut stateLitLength,
389 CTable_LitLength,
390 *llCodeTable.add(nbSeq.wrapping_sub(1)) as u32,
391 );
392 BIT_addBits(
393 &mut blockStream,
394 (*sequences.add(nbSeq.wrapping_sub(1))).litLength as BitContainerType,
395 *LL_bits
396 .as_ptr()
397 .offset(*llCodeTable.add(nbSeq.wrapping_sub(1)) as isize) as core::ffi::c_uint,
398 );
399 if MEM_32bits() != 0 {
400 BIT_flushBits(&mut blockStream);
401 }
402 BIT_addBits(
403 &mut blockStream,
404 (*sequences.add(nbSeq.wrapping_sub(1))).mlBase as BitContainerType,
405 *ML_bits
406 .as_ptr()
407 .offset(*mlCodeTable.add(nbSeq.wrapping_sub(1)) as isize) as core::ffi::c_uint,
408 );
409 if MEM_32bits() != 0 {
410 BIT_flushBits(&mut blockStream);
411 }
412 if longOffsets != 0 {
413 let ofBits = *ofCodeTable.add(nbSeq.wrapping_sub(1)) as u32;
414 let extraBits = ofBits.wrapping_sub(
415 if ofBits < ((if MEM_32bits() != 0 { 25 } else { 57 }) as u32).wrapping_sub(1) {
416 ofBits
417 } else {
418 ((if MEM_32bits() != 0 { 25 } else { 57 }) as u32).wrapping_sub(1)
419 },
420 );
421 if extraBits != 0 {
422 BIT_addBits(
423 &mut blockStream,
424 (*sequences.add(nbSeq.wrapping_sub(1))).offBase as BitContainerType,
425 extraBits,
426 );
427 BIT_flushBits(&mut blockStream);
428 }
429 BIT_addBits(
430 &mut blockStream,
431 ((*sequences.add(nbSeq.wrapping_sub(1))).offBase >> extraBits) as BitContainerType,
432 ofBits.wrapping_sub(extraBits),
433 );
434 } else {
435 BIT_addBits(
436 &mut blockStream,
437 (*sequences.add(nbSeq.wrapping_sub(1))).offBase as BitContainerType,
438 *ofCodeTable.add(nbSeq.wrapping_sub(1)) as core::ffi::c_uint,
439 );
440 }
441 BIT_flushBits(&mut blockStream);
442 let mut n: size_t = 0;
443 n = nbSeq.wrapping_sub(2);
444 while n < nbSeq {
445 let llCode = *llCodeTable.add(n);
446 let ofCode = *ofCodeTable.add(n);
447 let mlCode = *mlCodeTable.add(n);
448 let llBits = *LL_bits.as_ptr().offset(llCode as isize) as u32;
449 let ofBits_0 = ofCode as u32;
450 let mlBits = *ML_bits.as_ptr().offset(mlCode as isize) as u32;
451 FSE_encodeSymbol(
452 &mut blockStream,
453 &mut stateOffsetBits,
454 ofCode as core::ffi::c_uint,
455 );
456 FSE_encodeSymbol(
457 &mut blockStream,
458 &mut stateMatchLength,
459 mlCode as core::ffi::c_uint,
460 );
461 if MEM_32bits() != 0 {
462 BIT_flushBits(&mut blockStream);
463 }
464 FSE_encodeSymbol(
465 &mut blockStream,
466 &mut stateLitLength,
467 llCode as core::ffi::c_uint,
468 );
469 if MEM_32bits() != 0
470 || ofBits_0.wrapping_add(mlBits).wrapping_add(llBits)
471 >= (64 - 7 - (LLFSELog + MLFSELog + OffFSELog)) as u32
472 {
473 BIT_flushBits(&mut blockStream);
474 }
475 BIT_addBits(
476 &mut blockStream,
477 (*sequences.add(n)).litLength as BitContainerType,
478 llBits,
479 );
480 if MEM_32bits() != 0 && llBits.wrapping_add(mlBits) > 24 {
481 BIT_flushBits(&mut blockStream);
482 }
483 BIT_addBits(
484 &mut blockStream,
485 (*sequences.add(n)).mlBase as BitContainerType,
486 mlBits,
487 );
488 if MEM_32bits() != 0 || ofBits_0.wrapping_add(mlBits).wrapping_add(llBits) > 56 {
489 BIT_flushBits(&mut blockStream);
490 }
491 if longOffsets != 0 {
492 let extraBits_0 = ofBits_0.wrapping_sub(
493 if ofBits_0 < ((if MEM_32bits() != 0 { 25 } else { 57 }) as u32).wrapping_sub(1) {
494 ofBits_0
495 } else {
496 ((if MEM_32bits() != 0 { 25 } else { 57 }) as u32).wrapping_sub(1)
497 },
498 );
499 if extraBits_0 != 0 {
500 BIT_addBits(
501 &mut blockStream,
502 (*sequences.add(n)).offBase as BitContainerType,
503 extraBits_0,
504 );
505 BIT_flushBits(&mut blockStream);
506 }
507 BIT_addBits(
508 &mut blockStream,
509 ((*sequences.add(n)).offBase >> extraBits_0) as BitContainerType,
510 ofBits_0.wrapping_sub(extraBits_0),
511 );
512 } else {
513 BIT_addBits(
514 &mut blockStream,
515 (*sequences.add(n)).offBase as BitContainerType,
516 ofBits_0,
517 );
518 }
519 BIT_flushBits(&mut blockStream);
520 n = n.wrapping_sub(1);
521 }
522 FSE_flushCState(&mut blockStream, &stateMatchLength);
523 FSE_flushCState(&mut blockStream, &stateOffsetBits);
524 FSE_flushCState(&mut blockStream, &stateLitLength);
525 let streamSize = BIT_closeCStream(&mut blockStream);
526 if streamSize == 0 {
527 return Error::dstSize_tooSmall.to_error_code();
528 }
529 streamSize
530}
531unsafe fn ZSTD_encodeSequences_default(
532 dst: *mut core::ffi::c_void,
533 dstCapacity: size_t,
534 CTable_MatchLength: *const FSE_CTable,
535 mlCodeTable: *const u8,
536 CTable_OffsetBits: *const FSE_CTable,
537 ofCodeTable: *const u8,
538 CTable_LitLength: *const FSE_CTable,
539 llCodeTable: *const u8,
540 sequences: *const SeqDef,
541 nbSeq: size_t,
542 longOffsets: core::ffi::c_int,
543) -> size_t {
544 ZSTD_encodeSequences_body(
545 dst,
546 dstCapacity,
547 CTable_MatchLength,
548 mlCodeTable,
549 CTable_OffsetBits,
550 ofCodeTable,
551 CTable_LitLength,
552 llCodeTable,
553 sequences,
554 nbSeq,
555 longOffsets,
556 )
557}
558unsafe fn ZSTD_encodeSequences_bmi2(
559 dst: *mut core::ffi::c_void,
560 dstCapacity: size_t,
561 CTable_MatchLength: *const FSE_CTable,
562 mlCodeTable: *const u8,
563 CTable_OffsetBits: *const FSE_CTable,
564 ofCodeTable: *const u8,
565 CTable_LitLength: *const FSE_CTable,
566 llCodeTable: *const u8,
567 sequences: *const SeqDef,
568 nbSeq: size_t,
569 longOffsets: core::ffi::c_int,
570) -> size_t {
571 ZSTD_encodeSequences_body(
572 dst,
573 dstCapacity,
574 CTable_MatchLength,
575 mlCodeTable,
576 CTable_OffsetBits,
577 ofCodeTable,
578 CTable_LitLength,
579 llCodeTable,
580 sequences,
581 nbSeq,
582 longOffsets,
583 )
584}
585pub unsafe fn ZSTD_encodeSequences(
586 dst: *mut core::ffi::c_void,
587 dstCapacity: size_t,
588 CTable_MatchLength: *const FSE_CTable,
589 mlCodeTable: *const u8,
590 CTable_OffsetBits: *const FSE_CTable,
591 ofCodeTable: *const u8,
592 CTable_LitLength: *const FSE_CTable,
593 llCodeTable: *const u8,
594 sequences: *const SeqDef,
595 nbSeq: size_t,
596 longOffsets: core::ffi::c_int,
597 bmi2: core::ffi::c_int,
598) -> size_t {
599 if bmi2 != 0 {
600 return ZSTD_encodeSequences_bmi2(
601 dst,
602 dstCapacity,
603 CTable_MatchLength,
604 mlCodeTable,
605 CTable_OffsetBits,
606 ofCodeTable,
607 CTable_LitLength,
608 llCodeTable,
609 sequences,
610 nbSeq,
611 longOffsets,
612 );
613 }
614 ZSTD_encodeSequences_default(
615 dst,
616 dstCapacity,
617 CTable_MatchLength,
618 mlCodeTable,
619 CTable_OffsetBits,
620 ofCodeTable,
621 CTable_LitLength,
622 llCodeTable,
623 sequences,
624 nbSeq,
625 longOffsets,
626 )
627}