xref: /linux/include/linux/zstd.h (revision e61f33273ca755b3e2ebee4520a76097199dc7a8)
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  */
35 size_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  */
43 unsigned int zstd_is_error(size_t code);
44 
45 /**
46  * enum zstd_error_code - zstd error codes
47  */
48 typedef 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  */
56 zstd_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  */
64 const 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  */
71 int zstd_min_clevel(void);
72 
73 /**
74  * zstd_max_clevel() - maximum allowed compression level
75  *
76  * Return: The maximum allowed compression level.
77  */
78 int zstd_max_clevel(void);
79 
80 /**
81  * zstd_default_clevel() - default compression level
82  *
83  * Return: Default compression level.
84  */
85 int zstd_default_clevel(void);
86 
87 /**
88  * struct zstd_custom_mem - custom memory allocation
89  */
90 typedef ZSTD_customMem zstd_custom_mem;
91 
92 /**
93  * struct zstd_dict_load_method - Dictionary load method.
94  * See zstd_lib.h.
95  */
96 typedef ZSTD_dictLoadMethod_e zstd_dict_load_method;
97 
98 /**
99  * struct zstd_dict_content_type - Dictionary context type.
100  * See zstd_lib.h.
101  */
102 typedef 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  */
111 typedef 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  */
130 typedef 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  */
143 typedef ZSTD_frameParameters zstd_frame_parameters;
144 
145 /**
146  * struct zstd_parameters - zstd parameters
147  * @cParams: The compression parameters.
148  * @fParams: The frame parameters.
149  */
150 typedef 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  */
160 zstd_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  */
172 zstd_compression_parameters zstd_get_cparams(int level,
173 	unsigned long long estimated_src_size, size_t dict_size);
174 
175 typedef ZSTD_CCtx zstd_cctx;
176 typedef 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  */
186 size_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  */
201 size_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  */
215 size_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  */
226 zstd_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  */
241 size_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  */
250 zstd_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  */
258 size_t zstd_free_cctx(zstd_cctx* cctx);
259 
260 /**
261  * struct zstd_cdict - Compression dictionary.
262  * See zstd_lib.h.
263  */
264 typedef 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  */
280 zstd_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  */
290 size_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  */
305 size_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 
311 typedef 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  */
319 size_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  */
330 zstd_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  */
346 size_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  */
353 typedef 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  */
369 zstd_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  */
377 size_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  */
385 zstd_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  */
392 size_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  */
409 size_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  */
425 typedef 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  */
436 typedef ZSTD_outBuffer zstd_out_buffer;
437 
438 /* ======   Streaming Compression   ====== */
439 
440 typedef 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  */
449 size_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  */
459 size_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  */
476 zstd_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  */
491 size_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  */
511 size_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  */
527 size_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  */
541 size_t zstd_end_stream(zstd_cstream *cstream, zstd_out_buffer *output);
542 
543 /* ======   Streaming Decompression   ====== */
544 
545 typedef 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  */
554 size_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  */
567 zstd_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  */
579 size_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  */
602 size_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  */
618 size_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  */
625 typedef ZSTD_sequenceProducer_F zstd_sequence_producer_f;
626 void 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  */
645 typedef 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  */
657 size_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  */
668 typedef 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  */
686 size_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