Lines Matching +full:reserved +full:- +full:memory
1 /* SPDX-License-Identifier: 0BSD */
23 * - C99's 'true' and 'false' from stdbool.h;
24 * - C++'s internal 'true' and 'false'; or
25 * - integers one (true) and zero (false).
31 * \brief Type of reserved enumeration variable in structures
37 * a separate type to be used for reserved enumeration variables. All
38 * enumeration constants in liblzma API will be non-negative and less
53 * described per-function basis.
70 * output bytes should be picked from strm->next_out.
128 * \brief Cannot allocate memory
130 * Memory allocation failed, or the size of the allocation
134 * be continued even if more memory were made available after
140 * \brief Memory usage limit was reached
142 * Decoder would need more memory than allowed by the
143 * specified memory usage limit. To continue decoding,
144 * the memory usage limit has to be increased with
147 * liblzma 5.2.6 and earlier had a bug in single-threaded .xz
169 * - unsupported filter(s) or filter options; or
170 * - reserved bits set in headers (decoder only).
228 * - Function arguments are invalid or the structures
230 * e.g. if strm->next_out has been set to NULL and
231 * strm->avail_out > 0 when calling lzma_code().
232 * - lzma_* functions have been called in wrong order
234 * - If errors occur randomly, the reason might be flaky
279 * LZMA_STREAM_END. Also, the amount of input (that is, strm->avail_in) must
317 * LZMA2), fine-tuning the compression options may help
357 * With a lzma_stream initialized with the single-threaded
383 * \brief Custom functions for memory handling
388 * specified in lzma_allocator for memory handling instead of the default
389 * malloc() and free(). C++ users should note that the custom memory
392 * Single-threaded mode only: liblzma doesn't make an internal copy of
396 * memory allocated by the earlier 'alloc' function(s).
402 * to free the memory associated with that lzma_stream. The allocation
408 * \brief Pointer to a custom memory allocation function
423 * \return Pointer to the beginning of a memory block of
429 * This is not only about speed, but also memory usage, since the
431 * memory in physical memory until it is actually used. With small
433 * memory that it requested for allocation.
444 * \brief Pointer to a custom memory freeing function
462 * custom memory allocation functions for use with liblzma.
483 * - passing pointers to input and output buffers to liblzma;
484 * - defining custom memory handler functions; and
485 * - holding a pointer to coder-specific internal data structures.
489 * - After allocating lzma_stream (on stack or with malloc()), it must be
492 * - Initialize a coder to the lzma_stream, for example by using
494 * - In contrast to zlib, strm->next_in and strm->next_out are
497 * - The initialization functions always set strm->total_in and
498 * strm->total_out to zero.
499 * - If the initialization function fails, no memory is left allocated
500 * that would require freeing with lzma_end() even if some memory was
504 * - Use lzma_code() to do the actual work.
506 * - Once the coding has been finished, the existing lzma_stream can be
511 * - Finally, use lzma_end() to free the allocated memory. lzma_end() never
529 * \brief Custom memory allocation functions
542 * Reserved space to allow possible future extensions without
548 /** \private Reserved member. */
551 /** \private Reserved member. */
554 /** \private Reserved member. */
557 /** \private Reserved member. */
572 /** \private Reserved member. */
575 /** \private Reserved member. */
578 /** \private Reserved member. */
581 /** \private Reserved member. */
584 /** \private Reserved member. */
594 * initialize it so that initialization functions know that no memory
619 * using this function. The application has to update strm->next_in,
620 * strm->avail_in, strm->next_out, and strm->avail_out to pass input
623 * See the description of the coder-specific initialization function to find
639 * \brief Free memory allocated for the coder data structures
641 * After lzma_end(strm), strm->internal is guaranteed to be NULL. No other
657 * In single-threaded mode, applications can get progress information from
658 * strm->total_in and strm->total_out. In multi-threaded mode this is less
662 * non-smooth.
664 * This function gives realistic progress information also in multi-threaded
666 * single-threaded mode *progress_in and *progress_out are set to
667 * strm->total_in and strm->total_out, respectively.
679 * \brief Get the memory usage of decoder filter chain
684 * to estimate the memory requirements.
687 * the memory usage limit should have been to decode the input. Note that
689 * multiple Blocks, because each Block can have different memory requirements.
694 * \return How much memory is currently allocated for the filter
696 * some non-zero value is still returned, which is less than
698 * memory requirement.
708 * \brief Get the current memory usage limit
716 * \return On success, the current memory usage limit is returned
717 * (always non-zero). On error, zero is returned.
724 * \brief Set the memory usage limit
734 * liblzma 5.2.6 and earlier had a bug in single-threaded .xz decoder
740 * - LZMA_OK: New memory usage limit successfully set.
741 * - LZMA_MEMLIMIT_ERROR: The new limit is too small.
743 * - LZMA_PROG_ERROR: Invalid arguments, e.g. *strm doesn't
744 * support memory usage limit.