1/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */
2/*
3 * Copyright (c) Meta Platforms, Inc. and affiliates.
4 * All rights reserved.
5 *
6 * This source code is licensed under both the BSD-style license (found in the
7 * LICENSE file in the root directory of https://github.com/facebook/zstd) and
8 * the GPLv2 (found in the COPYING file in the root directory of
9 * https://github.com/facebook/zstd). You may select, at your option, one of the
10 * above-listed licenses.
11 */
12
13#ifndef LINUX_ZSTD_H
14#define LINUX_ZSTD_H
15
16/**
17 * This is a kernel-style API that wraps the upstream zstd API, which cannot be
18 * used directly because the symbols aren't exported. It exposes the minimal
19 * functionality which is currently required by users of zstd in the kernel.
20 * Expose extra functions from lib/zstd/zstd.h as needed.
21 */
22
23/* ====== Dependency ====== */
24#include <linux/types.h>
25#include <linux/zstd_errors.h>
26#include <linux/zstd_lib.h>
27
28/* ====== Helper Functions ====== */
29/**
30 * zstd_compress_bound() - maximum compressed size in worst case scenario
31 * @src_size: The size of the data to compress.
32 *
33 * Return: The maximum compressed size in the worst case scenario.
34 */
35size_t zstd_compress_bound(size_t src_size);
36
37/**
38 * zstd_is_error() - tells if a size_t function result is an error code
39 * @code: The function result to check for error.
40 *
41 * Return: Non-zero iff the code is an error.
42 */
43unsigned int zstd_is_error(size_t code);
44
45/**
46 * enum zstd_error_code - zstd error codes
47 */
48typedef ZSTD_ErrorCode zstd_error_code;
49
50/**
51 * zstd_get_error_code() - translates an error function result to an error code
52 * @code: The function result for which zstd_is_error(code) is true.
53 *
54 * Return: A unique error code for this error.
55 */
56zstd_error_code zstd_get_error_code(size_t code);
57
58/**
59 * zstd_get_error_name() - translates an error function result to a string
60 * @code: The function result for which zstd_is_error(code) is true.
61 *
62 * Return: An error string corresponding to the error code.
63 */
64const char *zstd_get_error_name(size_t code);
65
66/**
67 * zstd_min_clevel() - minimum allowed compression level
68 *
69 * Return: The minimum allowed compression level.
70 */
71int zstd_min_clevel(void);
72
73/**
74 * zstd_max_clevel() - maximum allowed compression level
75 *
76 * Return: The maximum allowed compression level.
77 */
78int zstd_max_clevel(void);
79
80/**
81 * zstd_default_clevel() - default compression level
82 *
83 * Return: Default compression level.
84 */
85int zstd_default_clevel(void);
86
87/**
88 * struct zstd_custom_mem - custom memory allocation
89 */
90typedef ZSTD_customMem zstd_custom_mem;
91
92/**
93 * struct zstd_dict_load_method - Dictionary load method.
94 * See zstd_lib.h.
95 */
96typedef ZSTD_dictLoadMethod_e zstd_dict_load_method;
97
98/**
99 * struct zstd_dict_content_type - Dictionary context type.
100 * See zstd_lib.h.
101 */
102typedef ZSTD_dictContentType_e zstd_dict_content_type;
103
104/* ====== Parameter Selection ====== */
105
106/**
107 * enum zstd_strategy - zstd compression search strategy
108 *
109 * From faster to stronger. See zstd_lib.h.
110 */
111typedef ZSTD_strategy zstd_strategy;
112
113/**
114 * struct zstd_compression_parameters - zstd compression parameters
115 * @windowLog: Log of the largest match distance. Larger means more
116 * compression, and more memory needed during decompression.
117 * @chainLog: Fully searched segment. Larger means more compression,
118 * slower, and more memory (useless for fast).
119 * @hashLog: Dispatch table. Larger means more compression,
120 * slower, and more memory.
121 * @searchLog: Number of searches. Larger means more compression and slower.
122 * @searchLength: Match length searched. Larger means faster decompression,
123 * sometimes less compression.
124 * @targetLength: Acceptable match size for optimal parser (only). Larger means
125 * more compression, and slower.
126 * @strategy: The zstd compression strategy.
127 *
128 * See zstd_lib.h.
129 */
130typedef ZSTD_compressionParameters zstd_compression_parameters;
131
132/**
133 * struct zstd_frame_parameters - zstd frame parameters
134 * @contentSizeFlag: Controls whether content size will be present in the
135 * frame header (when known).
136 * @checksumFlag: Controls whether a 32-bit checksum is generated at the
137 * end of the frame for error detection.
138 * @noDictIDFlag: Controls whether dictID will be saved into the frame
139 * header when using dictionary compression.
140 *
141 * The default value is all fields set to 0. See zstd_lib.h.
142 */
143typedef ZSTD_frameParameters zstd_frame_parameters;
144
145/**
146 * struct zstd_parameters - zstd parameters
147 * @cParams: The compression parameters.
148 * @fParams: The frame parameters.
149 */
150typedef ZSTD_parameters zstd_parameters;
151
152/**
153 * zstd_get_params() - returns zstd_parameters for selected level
154 * @level: The compression level
155 * @estimated_src_size: The estimated source size to compress or 0
156 * if unknown.
157 *
158 * Return: The selected zstd_parameters.
159 */
160zstd_parameters zstd_get_params(int level,
161 unsigned long long estimated_src_size);
162
163/**
164 * zstd_get_cparams() - returns zstd_compression_parameters for selected level
165 * @level: The compression level
166 * @estimated_src_size: The estimated source size to compress or 0
167 * if unknown.
168 * @dict_size: Dictionary size.
169 *
170 * Return: The selected zstd_compression_parameters.
171 */
172zstd_compression_parameters zstd_get_cparams(int level,
173 unsigned long long estimated_src_size, size_t dict_size);
174
175typedef ZSTD_CCtx zstd_cctx;
176typedef ZSTD_cParameter zstd_cparameter;
177
178/**
179 * zstd_cctx_set_param() - sets a compression parameter
180 * @cctx: The context. Must have been initialized with zstd_init_cctx().
181 * @param: The parameter to set.
182 * @value: The value to set the parameter to.
183 *
184 * Return: Zero or an error, which can be checked using zstd_is_error().
185 */
186size_t zstd_cctx_set_param(zstd_cctx *cctx, zstd_cparameter param, int value);
187
188/* ====== Single-pass Compression ====== */
189
190/**
191 * zstd_cctx_workspace_bound() - max memory needed to initialize a zstd_cctx
192 * @parameters: The compression parameters to be used.
193 *
194 * If multiple compression parameters might be used, the caller must call
195 * zstd_cctx_workspace_bound() for each set of parameters and use the maximum
196 * size.
197 *
198 * Return: A lower bound on the size of the workspace that is passed to
199 * zstd_init_cctx().
200 */
201size_t zstd_cctx_workspace_bound(const zstd_compression_parameters *parameters);
202
203/**
204 * zstd_cctx_workspace_bound_with_ext_seq_prod() - max memory needed to
205 * initialize a zstd_cctx when using the block-level external sequence
206 * producer API.
207 * @parameters: The compression parameters to be used.
208 *
209 * If multiple compression parameters might be used, the caller must call
210 * this function for each set of parameters and use the maximum size.
211 *
212 * Return: A lower bound on the size of the workspace that is passed to
213 * zstd_init_cctx().
214 */
215size_t zstd_cctx_workspace_bound_with_ext_seq_prod(const zstd_compression_parameters *parameters);
216
217/**
218 * zstd_init_cctx() - initialize a zstd compression context
219 * @workspace: The workspace to emplace the context into. It must outlive
220 * the returned context.
221 * @workspace_size: The size of workspace. Use zstd_cctx_workspace_bound() to
222 * determine how large the workspace must be.
223 *
224 * Return: A zstd compression context or NULL on error.
225 */
226zstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size);
227
228/**
229 * zstd_compress_cctx() - compress src into dst with the initialized parameters
230 * @cctx: The context. Must have been initialized with zstd_init_cctx().
231 * @dst: The buffer to compress src into.
232 * @dst_capacity: The size of the destination buffer. May be any size, but
233 * ZSTD_compressBound(srcSize) is guaranteed to be large enough.
234 * @src: The data to compress.
235 * @src_size: The size of the data to compress.
236 * @parameters: The compression parameters to be used.
237 *
238 * Return: The compressed size or an error, which can be checked using
239 * zstd_is_error().
240 */
241size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,
242 const void *src, size_t src_size, const zstd_parameters *parameters);
243
244/**
245 * zstd_create_cctx_advanced() - Create compression context
246 * @custom_mem: Custom allocator.
247 *
248 * Return: NULL on error, pointer to compression context otherwise.
249 */
250zstd_cctx *zstd_create_cctx_advanced(zstd_custom_mem custom_mem);
251
252/**
253 * zstd_free_cctx() - Free compression context
254 * @cdict: Pointer to compression context.
255 *
256 * Return: Always 0.
257 */
258size_t zstd_free_cctx(zstd_cctx* cctx);
259
260/**
261 * struct zstd_cdict - Compression dictionary.
262 * See zstd_lib.h.
263 */
264typedef ZSTD_CDict zstd_cdict;
265
266/**
267 * zstd_create_cdict_byreference() - Create compression dictionary
268 * @dict: Pointer to dictionary buffer.
269 * @dict_size: Size of the dictionary buffer.
270 * @dict_load_method: Dictionary load method.
271 * @dict_content_type: Dictionary content type.
272 * @custom_mem: Memory allocator.
273 *
274 * Note, this uses @dict by reference (ZSTD_dlm_byRef), so it should be
275 * free before zstd_cdict is destroyed.
276 *
277 * Return: NULL on error, pointer to compression dictionary
278 * otherwise.
279 */
280zstd_cdict *zstd_create_cdict_byreference(const void *dict, size_t dict_size,
281 zstd_compression_parameters cparams,
282 zstd_custom_mem custom_mem);
283
284/**
285 * zstd_free_cdict() - Free compression dictionary
286 * @cdict: Pointer to compression dictionary.
287 *
288 * Return: Always 0.
289 */
290size_t zstd_free_cdict(zstd_cdict* cdict);
291
292/**
293 * zstd_compress_using_cdict() - compress src into dst using a dictionary
294 * @cctx: The context. Must have been initialized with zstd_init_cctx().
295 * @dst: The buffer to compress src into.
296 * @dst_capacity: The size of the destination buffer. May be any size, but
297 * ZSTD_compressBound(srcSize) is guaranteed to be large enough.
298 * @src: The data to compress.
299 * @src_size: The size of the data to compress.
300 * @cdict: The dictionary to be used.
301 *
302 * Return: The compressed size or an error, which can be checked using
303 * zstd_is_error().
304 */
305size_t zstd_compress_using_cdict(zstd_cctx *cctx, void *dst,
306 size_t dst_capacity, const void *src, size_t src_size,
307 const zstd_cdict *cdict);
308
309/* ====== Single-pass Decompression ====== */
310
311typedef ZSTD_DCtx zstd_dctx;
312
313/**
314 * zstd_dctx_workspace_bound() - max memory needed to initialize a zstd_dctx
315 *
316 * Return: A lower bound on the size of the workspace that is passed to
317 * zstd_init_dctx().
318 */
319size_t zstd_dctx_workspace_bound(void);
320
321/**
322 * zstd_init_dctx() - initialize a zstd decompression context
323 * @workspace: The workspace to emplace the context into. It must outlive
324 * the returned context.
325 * @workspace_size: The size of workspace. Use zstd_dctx_workspace_bound() to
326 * determine how large the workspace must be.
327 *
328 * Return: A zstd decompression context or NULL on error.
329 */
330zstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size);
331
332/**
333 * zstd_decompress_dctx() - decompress zstd compressed src into dst
334 * @dctx: The decompression context.
335 * @dst: The buffer to decompress src into.
336 * @dst_capacity: The size of the destination buffer. Must be at least as large
337 * as the decompressed size. If the caller cannot upper bound the
338 * decompressed size, then it's better to use the streaming API.
339 * @src: The zstd compressed data to decompress. Multiple concatenated
340 * frames and skippable frames are allowed.
341 * @src_size: The exact size of the data to decompress.
342 *
343 * Return: The decompressed size or an error, which can be checked using
344 * zstd_is_error().
345 */
346size_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,
347 const void *src, size_t src_size);
348
349/**
350 * struct zstd_ddict - Decompression dictionary.
351 * See zstd_lib.h.
352 */
353typedef ZSTD_DDict zstd_ddict;
354
355/**
356 * zstd_create_ddict_byreference() - Create decompression dictionary
357 * @dict: Pointer to dictionary buffer.
358 * @dict_size: Size of the dictionary buffer.
359 * @dict_load_method: Dictionary load method.
360 * @dict_content_type: Dictionary content type.
361 * @custom_mem: Memory allocator.
362 *
363 * Note, this uses @dict by reference (ZSTD_dlm_byRef), so it should be
364 * free before zstd_ddict is destroyed.
365 *
366 * Return: NULL on error, pointer to decompression dictionary
367 * otherwise.
368 */
369zstd_ddict *zstd_create_ddict_byreference(const void *dict, size_t dict_size,
370 zstd_custom_mem custom_mem);
371/**
372 * zstd_free_ddict() - Free decompression dictionary
373 * @dict: Pointer to the dictionary.
374 *
375 * Return: Always 0.
376 */
377size_t zstd_free_ddict(zstd_ddict *ddict);
378
379/**
380 * zstd_create_dctx_advanced() - Create decompression context
381 * @custom_mem: Custom allocator.
382 *
383 * Return: NULL on error, pointer to decompression context otherwise.
384 */
385zstd_dctx *zstd_create_dctx_advanced(zstd_custom_mem custom_mem);
386
387/**
388 * zstd_free_dctx() -- Free decompression context
389 * @dctx: Pointer to decompression context.
390 * Return: Always 0.
391 */
392size_t zstd_free_dctx(zstd_dctx *dctx);
393
394/**
395 * zstd_decompress_using_ddict() - decompress src into dst using a dictionary
396 * @dctx: The decompression context.
397 * @dst: The buffer to decompress src into.
398 * @dst_capacity: The size of the destination buffer. Must be at least as large
399 * as the decompressed size. If the caller cannot upper bound the
400 * decompressed size, then it's better to use the streaming API.
401 * @src: The zstd compressed data to decompress. Multiple concatenated
402 * frames and skippable frames are allowed.
403 * @src_size: The exact size of the data to decompress.
404 * @ddict: The dictionary to be used.
405 *
406 * Return: The decompressed size or an error, which can be checked using
407 * zstd_is_error().
408 */
409size_t zstd_decompress_using_ddict(zstd_dctx *dctx,
410 void *dst, size_t dst_capacity, const void *src, size_t src_size,
411 const zstd_ddict *ddict);
412
413
414/* ====== Streaming Buffers ====== */
415
416/**
417 * struct zstd_in_buffer - input buffer for streaming
418 * @src: Start of the input buffer.
419 * @size: Size of the input buffer.
420 * @pos: Position where reading stopped. Will be updated.
421 * Necessarily 0 <= pos <= size.
422 *
423 * See zstd_lib.h.
424 */
425typedef ZSTD_inBuffer zstd_in_buffer;
426
427/**
428 * struct zstd_out_buffer - output buffer for streaming
429 * @dst: Start of the output buffer.
430 * @size: Size of the output buffer.
431 * @pos: Position where writing stopped. Will be updated.
432 * Necessarily 0 <= pos <= size.
433 *
434 * See zstd_lib.h.
435 */
436typedef ZSTD_outBuffer zstd_out_buffer;
437
438/* ====== Streaming Compression ====== */
439
440typedef ZSTD_CStream zstd_cstream;
441
442/**
443 * zstd_cstream_workspace_bound() - memory needed to initialize a zstd_cstream
444 * @cparams: The compression parameters to be used for compression.
445 *
446 * Return: A lower bound on the size of the workspace that is passed to
447 * zstd_init_cstream().
448 */
449size_t zstd_cstream_workspace_bound(const zstd_compression_parameters *cparams);
450
451/**
452 * zstd_cstream_workspace_bound_with_ext_seq_prod() - memory needed to initialize
453 * a zstd_cstream when using the block-level external sequence producer API.
454 * @cparams: The compression parameters to be used for compression.
455 *
456 * Return: A lower bound on the size of the workspace that is passed to
457 * zstd_init_cstream().
458 */
459size_t zstd_cstream_workspace_bound_with_ext_seq_prod(const zstd_compression_parameters *cparams);
460
461/**
462 * zstd_init_cstream() - initialize a zstd streaming compression context
463 * @parameters The zstd parameters to use for compression.
464 * @pledged_src_size: If params.fParams.contentSizeFlag == 1 then the caller
465 * must pass the source size (zero means empty source).
466 * Otherwise, the caller may optionally pass the source
467 * size, or zero if unknown.
468 * @workspace: The workspace to emplace the context into. It must outlive
469 * the returned context.
470 * @workspace_size: The size of workspace.
471 * Use zstd_cstream_workspace_bound(params->cparams) to
472 * determine how large the workspace must be.
473 *
474 * Return: The zstd streaming compression context or NULL on error.
475 */
476zstd_cstream *zstd_init_cstream(const zstd_parameters *parameters,
477 unsigned long long pledged_src_size, void *workspace, size_t workspace_size);
478
479/**
480 * zstd_reset_cstream() - reset the context using parameters from creation
481 * @cstream: The zstd streaming compression context to reset.
482 * @pledged_src_size: Optionally the source size, or zero if unknown.
483 *
484 * Resets the context using the parameters from creation. Skips dictionary
485 * loading, since it can be reused. If `pledged_src_size` is non-zero the frame
486 * content size is always written into the frame header.
487 *
488 * Return: Zero or an error, which can be checked using
489 * zstd_is_error().
490 */
491size_t zstd_reset_cstream(zstd_cstream *cstream,
492 unsigned long long pledged_src_size);
493
494/**
495 * zstd_compress_stream() - streaming compress some of input into output
496 * @cstream: The zstd streaming compression context.
497 * @output: Destination buffer. `output->pos` is updated to indicate how much
498 * compressed data was written.
499 * @input: Source buffer. `input->pos` is updated to indicate how much data
500 * was read. Note that it may not consume the entire input, in which
501 * case `input->pos < input->size`, and it's up to the caller to
502 * present remaining data again.
503 *
504 * The `input` and `output` buffers may be any size. Guaranteed to make some
505 * forward progress if `input` and `output` are not empty.
506 *
507 * Return: A hint for the number of bytes to use as the input for the next
508 * function call or an error, which can be checked using
509 * zstd_is_error().
510 */
511size_t zstd_compress_stream(zstd_cstream *cstream, zstd_out_buffer *output,
512 zstd_in_buffer *input);
513
514/**
515 * zstd_flush_stream() - flush internal buffers into output
516 * @cstream: The zstd streaming compression context.
517 * @output: Destination buffer. `output->pos` is updated to indicate how much
518 * compressed data was written.
519 *
520 * zstd_flush_stream() must be called until it returns 0, meaning all the data
521 * has been flushed. Since zstd_flush_stream() causes a block to be ended,
522 * calling it too often will degrade the compression ratio.
523 *
524 * Return: The number of bytes still present within internal buffers or an
525 * error, which can be checked using zstd_is_error().
526 */
527size_t zstd_flush_stream(zstd_cstream *cstream, zstd_out_buffer *output);
528
529/**
530 * zstd_end_stream() - flush internal buffers into output and end the frame
531 * @cstream: The zstd streaming compression context.
532 * @output: Destination buffer. `output->pos` is updated to indicate how much
533 * compressed data was written.
534 *
535 * zstd_end_stream() must be called until it returns 0, meaning all the data has
536 * been flushed and the frame epilogue has been written.
537 *
538 * Return: The number of bytes still present within internal buffers or an
539 * error, which can be checked using zstd_is_error().
540 */
541size_t zstd_end_stream(zstd_cstream *cstream, zstd_out_buffer *output);
542
543/* ====== Streaming Decompression ====== */
544
545typedef ZSTD_DStream zstd_dstream;
546
547/**
548 * zstd_dstream_workspace_bound() - memory needed to initialize a zstd_dstream
549 * @max_window_size: The maximum window size allowed for compressed frames.
550 *
551 * Return: A lower bound on the size of the workspace that is passed
552 * to zstd_init_dstream().
553 */
554size_t zstd_dstream_workspace_bound(size_t max_window_size);
555
556/**
557 * zstd_init_dstream() - initialize a zstd streaming decompression context
558 * @max_window_size: The maximum window size allowed for compressed frames.
559 * @workspace: The workspace to emplace the context into. It must outlive
560 * the returned context.
561 * @workspaceSize: The size of workspace.
562 * Use zstd_dstream_workspace_bound(max_window_size) to
563 * determine how large the workspace must be.
564 *
565 * Return: The zstd streaming decompression context.
566 */
567zstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,
568 size_t workspace_size);
569
570/**
571 * zstd_reset_dstream() - reset the context using parameters from creation
572 * @dstream: The zstd streaming decompression context to reset.
573 *
574 * Resets the context using the parameters from creation. Skips dictionary
575 * loading, since it can be reused.
576 *
577 * Return: Zero or an error, which can be checked using zstd_is_error().
578 */
579size_t zstd_reset_dstream(zstd_dstream *dstream);
580
581/**
582 * zstd_decompress_stream() - streaming decompress some of input into output
583 * @dstream: The zstd streaming decompression context.
584 * @output: Destination buffer. `output.pos` is updated to indicate how much
585 * decompressed data was written.
586 * @input: Source buffer. `input.pos` is updated to indicate how much data was
587 * read. Note that it may not consume the entire input, in which case
588 * `input.pos < input.size`, and it's up to the caller to present
589 * remaining data again.
590 *
591 * The `input` and `output` buffers may be any size. Guaranteed to make some
592 * forward progress if `input` and `output` are not empty.
593 * zstd_decompress_stream() will not consume the last byte of the frame until
594 * the entire frame is flushed.
595 *
596 * Return: Returns 0 iff a frame is completely decoded and fully flushed.
597 * Otherwise returns a hint for the number of bytes to use as the
598 * input for the next function call or an error, which can be checked
599 * using zstd_is_error(). The size hint will never load more than the
600 * frame.
601 */
602size_t zstd_decompress_stream(zstd_dstream *dstream, zstd_out_buffer *output,
603 zstd_in_buffer *input);
604
605/* ====== Frame Inspection Functions ====== */
606
607/**
608 * zstd_find_frame_compressed_size() - returns the size of a compressed frame
609 * @src: Source buffer. It should point to the start of a zstd encoded
610 * frame or a skippable frame.
611 * @src_size: The size of the source buffer. It must be at least as large as the
612 * size of the frame.
613 *
614 * Return: The compressed size of the frame pointed to by `src` or an error,
615 * which can be check with zstd_is_error().
616 * Suitable to pass to ZSTD_decompress() or similar functions.
617 */
618size_t zstd_find_frame_compressed_size(const void *src, size_t src_size);
619
620/**
621 * zstd_register_sequence_producer() - exposes the zstd library function
622 * ZSTD_registerSequenceProducer(). This is used for the block-level external
623 * sequence producer API. See upstream zstd.h for detailed documentation.
624 */
625typedef ZSTD_sequenceProducer_F zstd_sequence_producer_f;
626void zstd_register_sequence_producer(
627 zstd_cctx *cctx,
628 void* sequence_producer_state,
629 zstd_sequence_producer_f sequence_producer
630);
631
632/**
633 * struct zstd_frame_params - zstd frame parameters stored in the frame header
634 * @frameContentSize: The frame content size, or ZSTD_CONTENTSIZE_UNKNOWN if not
635 * present.
636 * @windowSize: The window size, or 0 if the frame is a skippable frame.
637 * @blockSizeMax: The maximum block size.
638 * @frameType: The frame type (zstd or skippable)
639 * @headerSize: The size of the frame header.
640 * @dictID: The dictionary id, or 0 if not present.
641 * @checksumFlag: Whether a checksum was used.
642 *
643 * See zstd_lib.h.
644 */
645typedef ZSTD_FrameHeader zstd_frame_header;
646
647/**
648 * zstd_get_frame_header() - extracts parameters from a zstd or skippable frame
649 * @params: On success the frame parameters are written here.
650 * @src: The source buffer. It must point to a zstd or skippable frame.
651 * @src_size: The size of the source buffer.
652 *
653 * Return: 0 on success. If more data is required it returns how many bytes
654 * must be provided to make forward progress. Otherwise it returns
655 * an error, which can be checked using zstd_is_error().
656 */
657size_t zstd_get_frame_header(zstd_frame_header *params, const void *src,
658 size_t src_size);
659
660/**
661 * struct zstd_sequence - a sequence of literals or a match
662 *
663 * @offset: The offset of the match
664 * @litLength: The literal length of the sequence
665 * @matchLength: The match length of the sequence
666 * @rep: Represents which repeat offset is used
667 */
668typedef ZSTD_Sequence zstd_sequence;
669
670/**
671 * zstd_compress_sequences_and_literals() - compress an array of zstd_sequence and literals
672 *
673 * @cctx: The zstd compression context.
674 * @dst: The buffer to compress the data into.
675 * @dst_capacity: The size of the destination buffer.
676 * @in_seqs: The array of zstd_sequence to compress.
677 * @in_seqs_size: The number of sequences in in_seqs.
678 * @literals: The literals associated to the sequences to be compressed.
679 * @lit_size: The size of the literals in the literals buffer.
680 * @lit_capacity: The size of the literals buffer.
681 * @decompressed_size: The size of the input data
682 *
683 * Return: The compressed size or an error, which can be checked using
684 * zstd_is_error().
685 */
686size_t zstd_compress_sequences_and_literals(zstd_cctx *cctx, void* dst, size_t dst_capacity,
687 const zstd_sequence *in_seqs, size_t in_seqs_size,
688 const void* literals, size_t lit_size, size_t lit_capacity,
689 size_t decompressed_size);
690
691#endif /* LINUX_ZSTD_H */
692

source code of linux/include/linux/zstd.h

Morty Proxy This is a proxified and sanitized view of the page, visit original site.