]> pd.if.org Git - zpackage/blob - lzma/api/lzma/index.h
add newline to zpm-stat usage message
[zpackage] / lzma / api / lzma / index.h
1 /**
2  * \file        lzma/index.h
3  * \brief       Handling of .xz Index and related information
4  */
5
6 /*
7  * Author: Lasse Collin
8  *
9  * This file has been put into the public domain.
10  * You can do whatever you want with this file.
11  *
12  * See ../lzma.h for information about liblzma as a whole.
13  */
14
15 #ifndef LZMA_H_INTERNAL
16 #       error Never include this file directly. Use <lzma.h> instead.
17 #endif
18
19
20 /**
21  * \brief       Opaque data type to hold the Index(es) and other information
22  *
23  * lzma_index often holds just one .xz Index and possibly the Stream Flags
24  * of the same Stream and size of the Stream Padding field. However,
25  * multiple lzma_indexes can be concatenated with lzma_index_cat() and then
26  * there may be information about multiple Streams in the same lzma_index.
27  *
28  * Notes about thread safety: Only one thread may modify lzma_index at
29  * a time. All functions that take non-const pointer to lzma_index
30  * modify it. As long as no thread is modifying the lzma_index, getting
31  * information from the same lzma_index can be done from multiple threads
32  * at the same time with functions that take a const pointer to
33  * lzma_index or use lzma_index_iter. The same iterator must be used
34  * only by one thread at a time, of course, but there can be as many
35  * iterators for the same lzma_index as needed.
36  */
37 typedef struct lzma_index_s lzma_index;
38
39
40 /**
41  * \brief       Iterator to get information about Blocks and Streams
42  */
43 typedef struct {
44         struct {
45                 /**
46                  * \brief       Pointer to Stream Flags
47                  *
48                  * This is NULL if Stream Flags have not been set for
49                  * this Stream with lzma_index_stream_flags().
50                  */
51                 const lzma_stream_flags *flags;
52
53                 const void *reserved_ptr1;
54                 const void *reserved_ptr2;
55                 const void *reserved_ptr3;
56
57                 /**
58                  * \brief       Stream number in the lzma_index
59                  *
60                  * The first Stream is 1.
61                  */
62                 lzma_vli number;
63
64                 /**
65                  * \brief       Number of Blocks in the Stream
66                  *
67                  * If this is zero, the block structure below has
68                  * undefined values.
69                  */
70                 lzma_vli block_count;
71
72                 /**
73                  * \brief       Compressed start offset of this Stream
74                  *
75                  * The offset is relative to the beginning of the lzma_index
76                  * (i.e. usually the beginning of the .xz file).
77                  */
78                 lzma_vli compressed_offset;
79
80                 /**
81                  * \brief       Uncompressed start offset of this Stream
82                  *
83                  * The offset is relative to the beginning of the lzma_index
84                  * (i.e. usually the beginning of the .xz file).
85                  */
86                 lzma_vli uncompressed_offset;
87
88                 /**
89                  * \brief       Compressed size of this Stream
90                  *
91                  * This includes all headers except the possible
92                  * Stream Padding after this Stream.
93                  */
94                 lzma_vli compressed_size;
95
96                 /**
97                  * \brief       Uncompressed size of this Stream
98                  */
99                 lzma_vli uncompressed_size;
100
101                 /**
102                  * \brief       Size of Stream Padding after this Stream
103                  *
104                  * If it hasn't been set with lzma_index_stream_padding(),
105                  * this defaults to zero. Stream Padding is always
106                  * a multiple of four bytes.
107                  */
108                 lzma_vli padding;
109
110                 lzma_vli reserved_vli1;
111                 lzma_vli reserved_vli2;
112                 lzma_vli reserved_vli3;
113                 lzma_vli reserved_vli4;
114         } stream;
115
116         struct {
117                 /**
118                  * \brief       Block number in the file
119                  *
120                  * The first Block is 1.
121                  */
122                 lzma_vli number_in_file;
123
124                 /**
125                  * \brief       Compressed start offset of this Block
126                  *
127                  * This offset is relative to the beginning of the
128                  * lzma_index (i.e. usually the beginning of the .xz file).
129                  * Normally this is where you should seek in the .xz file
130                  * to start decompressing this Block.
131                  */
132                 lzma_vli compressed_file_offset;
133
134                 /**
135                  * \brief       Uncompressed start offset of this Block
136                  *
137                  * This offset is relative to the beginning of the lzma_index
138                  * (i.e. usually the beginning of the .xz file).
139                  *
140                  * When doing random-access reading, it is possible that
141                  * the target offset is not exactly at Block boundary. One
142                  * will need to compare the target offset against
143                  * uncompressed_file_offset or uncompressed_stream_offset,
144                  * and possibly decode and throw away some amount of data
145                  * before reaching the target offset.
146                  */
147                 lzma_vli uncompressed_file_offset;
148
149                 /**
150                  * \brief       Block number in this Stream
151                  *
152                  * The first Block is 1.
153                  */
154                 lzma_vli number_in_stream;
155
156                 /**
157                  * \brief       Compressed start offset of this Block
158                  *
159                  * This offset is relative to the beginning of the Stream
160                  * containing this Block.
161                  */
162                 lzma_vli compressed_stream_offset;
163
164                 /**
165                  * \brief       Uncompressed start offset of this Block
166                  *
167                  * This offset is relative to the beginning of the Stream
168                  * containing this Block.
169                  */
170                 lzma_vli uncompressed_stream_offset;
171
172                 /**
173                  * \brief       Uncompressed size of this Block
174                  *
175                  * You should pass this to the Block decoder if you will
176                  * decode this Block. It will allow the Block decoder to
177                  * validate the uncompressed size.
178                  */
179                 lzma_vli uncompressed_size;
180
181                 /**
182                  * \brief       Unpadded size of this Block
183                  *
184                  * You should pass this to the Block decoder if you will
185                  * decode this Block. It will allow the Block decoder to
186                  * validate the unpadded size.
187                  */
188                 lzma_vli unpadded_size;
189
190                 /**
191                  * \brief       Total compressed size
192                  *
193                  * This includes all headers and padding in this Block.
194                  * This is useful if you need to know how many bytes
195                  * the Block decoder will actually read.
196                  */
197                 lzma_vli total_size;
198
199                 lzma_vli reserved_vli1;
200                 lzma_vli reserved_vli2;
201                 lzma_vli reserved_vli3;
202                 lzma_vli reserved_vli4;
203
204                 const void *reserved_ptr1;
205                 const void *reserved_ptr2;
206                 const void *reserved_ptr3;
207                 const void *reserved_ptr4;
208         } block;
209
210         /*
211          * Internal data which is used to store the state of the iterator.
212          * The exact format may vary between liblzma versions, so don't
213          * touch these in any way.
214          */
215         union {
216                 const void *p;
217                 size_t s;
218                 lzma_vli v;
219         } internal[6];
220 } lzma_index_iter;
221
222
223 /**
224  * \brief       Operation mode for lzma_index_iter_next()
225  */
226 typedef enum {
227         LZMA_INDEX_ITER_ANY             = 0,
228                 /**<
229                  * \brief       Get the next Block or Stream
230                  *
231                  * Go to the next Block if the current Stream has at least
232                  * one Block left. Otherwise go to the next Stream even if
233                  * it has no Blocks. If the Stream has no Blocks
234                  * (lzma_index_iter.stream.block_count == 0),
235                  * lzma_index_iter.block will have undefined values.
236                  */
237
238         LZMA_INDEX_ITER_STREAM          = 1,
239                 /**<
240                  * \brief       Get the next Stream
241                  *
242                  * Go to the next Stream even if the current Stream has
243                  * unread Blocks left. If the next Stream has at least one
244                  * Block, the iterator will point to the first Block.
245                  * If there are no Blocks, lzma_index_iter.block will have
246                  * undefined values.
247                  */
248
249         LZMA_INDEX_ITER_BLOCK           = 2,
250                 /**<
251                  * \brief       Get the next Block
252                  *
253                  * Go to the next Block if the current Stream has at least
254                  * one Block left. If the current Stream has no Blocks left,
255                  * the next Stream with at least one Block is located and
256                  * the iterator will be made to point to the first Block of
257                  * that Stream.
258                  */
259
260         LZMA_INDEX_ITER_NONEMPTY_BLOCK  = 3
261                 /**<
262                  * \brief       Get the next non-empty Block
263                  *
264                  * This is like LZMA_INDEX_ITER_BLOCK except that it will
265                  * skip Blocks whose Uncompressed Size is zero.
266                  */
267
268 } lzma_index_iter_mode;
269
270
271 /**
272  * \brief       Calculate memory usage of lzma_index
273  *
274  * On disk, the size of the Index field depends on both the number of Records
275  * stored and how big values the Records store (due to variable-length integer
276  * encoding). When the Index is kept in lzma_index structure, the memory usage
277  * depends only on the number of Records/Blocks stored in the Index(es), and
278  * in case of concatenated lzma_indexes, the number of Streams. The size in
279  * RAM is almost always significantly bigger than in the encoded form on disk.
280  *
281  * This function calculates an approximate amount of memory needed hold
282  * the given number of Streams and Blocks in lzma_index structure. This
283  * value may vary between CPU architectures and also between liblzma versions
284  * if the internal implementation is modified.
285  */
286 extern LZMA_API(uint64_t) lzma_index_memusage(
287                 lzma_vli streams, lzma_vli blocks) lzma_nothrow;
288
289
290 /**
291  * \brief       Calculate the memory usage of an existing lzma_index
292  *
293  * This is a shorthand for lzma_index_memusage(lzma_index_stream_count(i),
294  * lzma_index_block_count(i)).
295  */
296 extern LZMA_API(uint64_t) lzma_index_memused(const lzma_index *i)
297                 lzma_nothrow;
298
299
300 /**
301  * \brief       Allocate and initialize a new lzma_index structure
302  *
303  * \return      On success, a pointer to an empty initialized lzma_index is
304  *              returned. If allocation fails, NULL is returned.
305  */
306 extern LZMA_API(lzma_index *) lzma_index_init(const lzma_allocator *allocator)
307                 lzma_nothrow;
308
309
310 /**
311  * \brief       Deallocate lzma_index
312  *
313  * If i is NULL, this does nothing.
314  */
315 extern LZMA_API(void) lzma_index_end(
316                 lzma_index *i, const lzma_allocator *allocator) lzma_nothrow;
317
318
319 /**
320  * \brief       Add a new Block to lzma_index
321  *
322  * \param       i                 Pointer to a lzma_index structure
323  * \param       allocator         Pointer to lzma_allocator, or NULL to
324  *                                use malloc()
325  * \param       unpadded_size     Unpadded Size of a Block. This can be
326  *                                calculated with lzma_block_unpadded_size()
327  *                                after encoding or decoding the Block.
328  * \param       uncompressed_size Uncompressed Size of a Block. This can be
329  *                                taken directly from lzma_block structure
330  *                                after encoding or decoding the Block.
331  *
332  * Appending a new Block does not invalidate iterators. For example,
333  * if an iterator was pointing to the end of the lzma_index, after
334  * lzma_index_append() it is possible to read the next Block with
335  * an existing iterator.
336  *
337  * \return      - LZMA_OK
338  *              - LZMA_MEM_ERROR
339  *              - LZMA_DATA_ERROR: Compressed or uncompressed size of the
340  *                Stream or size of the Index field would grow too big.
341  *              - LZMA_PROG_ERROR
342  */
343 extern LZMA_API(lzma_ret) lzma_index_append(
344                 lzma_index *i, const lzma_allocator *allocator,
345                 lzma_vli unpadded_size, lzma_vli uncompressed_size)
346                 lzma_nothrow lzma_attr_warn_unused_result;
347
348
349 /**
350  * \brief       Set the Stream Flags
351  *
352  * Set the Stream Flags of the last (and typically the only) Stream
353  * in lzma_index. This can be useful when reading information from the
354  * lzma_index, because to decode Blocks, knowing the integrity check type
355  * is needed.
356  *
357  * The given Stream Flags are copied into internal preallocated structure
358  * in the lzma_index, thus the caller doesn't need to keep the *stream_flags
359  * available after calling this function.
360  *
361  * \return      - LZMA_OK
362  *              - LZMA_OPTIONS_ERROR: Unsupported stream_flags->version.
363  *              - LZMA_PROG_ERROR
364  */
365 extern LZMA_API(lzma_ret) lzma_index_stream_flags(
366                 lzma_index *i, const lzma_stream_flags *stream_flags)
367                 lzma_nothrow lzma_attr_warn_unused_result;
368
369
370 /**
371  * \brief       Get the types of integrity Checks
372  *
373  * If lzma_index_stream_flags() is used to set the Stream Flags for
374  * every Stream, lzma_index_checks() can be used to get a bitmask to
375  * indicate which Check types have been used. It can be useful e.g. if
376  * showing the Check types to the user.
377  *
378  * The bitmask is 1 << check_id, e.g. CRC32 is 1 << 1 and SHA-256 is 1 << 10.
379  */
380 extern LZMA_API(uint32_t) lzma_index_checks(const lzma_index *i)
381                 lzma_nothrow lzma_attr_pure;
382
383
384 /**
385  * \brief       Set the amount of Stream Padding
386  *
387  * Set the amount of Stream Padding of the last (and typically the only)
388  * Stream in the lzma_index. This is needed when planning to do random-access
389  * reading within multiple concatenated Streams.
390  *
391  * By default, the amount of Stream Padding is assumed to be zero bytes.
392  *
393  * \return      - LZMA_OK
394  *              - LZMA_DATA_ERROR: The file size would grow too big.
395  *              - LZMA_PROG_ERROR
396  */
397 extern LZMA_API(lzma_ret) lzma_index_stream_padding(
398                 lzma_index *i, lzma_vli stream_padding)
399                 lzma_nothrow lzma_attr_warn_unused_result;
400
401
402 /**
403  * \brief       Get the number of Streams
404  */
405 extern LZMA_API(lzma_vli) lzma_index_stream_count(const lzma_index *i)
406                 lzma_nothrow lzma_attr_pure;
407
408
409 /**
410  * \brief       Get the number of Blocks
411  *
412  * This returns the total number of Blocks in lzma_index. To get number
413  * of Blocks in individual Streams, use lzma_index_iter.
414  */
415 extern LZMA_API(lzma_vli) lzma_index_block_count(const lzma_index *i)
416                 lzma_nothrow lzma_attr_pure;
417
418
419 /**
420  * \brief       Get the size of the Index field as bytes
421  *
422  * This is needed to verify the Backward Size field in the Stream Footer.
423  */
424 extern LZMA_API(lzma_vli) lzma_index_size(const lzma_index *i)
425                 lzma_nothrow lzma_attr_pure;
426
427
428 /**
429  * \brief       Get the total size of the Stream
430  *
431  * If multiple lzma_indexes have been combined, this works as if the Blocks
432  * were in a single Stream. This is useful if you are going to combine
433  * Blocks from multiple Streams into a single new Stream.
434  */
435 extern LZMA_API(lzma_vli) lzma_index_stream_size(const lzma_index *i)
436                 lzma_nothrow lzma_attr_pure;
437
438
439 /**
440  * \brief       Get the total size of the Blocks
441  *
442  * This doesn't include the Stream Header, Stream Footer, Stream Padding,
443  * or Index fields.
444  */
445 extern LZMA_API(lzma_vli) lzma_index_total_size(const lzma_index *i)
446                 lzma_nothrow lzma_attr_pure;
447
448
449 /**
450  * \brief       Get the total size of the file
451  *
452  * When no lzma_indexes have been combined with lzma_index_cat() and there is
453  * no Stream Padding, this function is identical to lzma_index_stream_size().
454  * If multiple lzma_indexes have been combined, this includes also the headers
455  * of each separate Stream and the possible Stream Padding fields.
456  */
457 extern LZMA_API(lzma_vli) lzma_index_file_size(const lzma_index *i)
458                 lzma_nothrow lzma_attr_pure;
459
460
461 /**
462  * \brief       Get the uncompressed size of the file
463  */
464 extern LZMA_API(lzma_vli) lzma_index_uncompressed_size(const lzma_index *i)
465                 lzma_nothrow lzma_attr_pure;
466
467
468 /**
469  * \brief       Initialize an iterator
470  *
471  * \param       iter    Pointer to a lzma_index_iter structure
472  * \param       i       lzma_index to which the iterator will be associated
473  *
474  * This function associates the iterator with the given lzma_index, and calls
475  * lzma_index_iter_rewind() on the iterator.
476  *
477  * This function doesn't allocate any memory, thus there is no
478  * lzma_index_iter_end(). The iterator is valid as long as the
479  * associated lzma_index is valid, that is, until lzma_index_end() or
480  * using it as source in lzma_index_cat(). Specifically, lzma_index doesn't
481  * become invalid if new Blocks are added to it with lzma_index_append() or
482  * if it is used as the destination in lzma_index_cat().
483  *
484  * It is safe to make copies of an initialized lzma_index_iter, for example,
485  * to easily restart reading at some particular position.
486  */
487 extern LZMA_API(void) lzma_index_iter_init(
488                 lzma_index_iter *iter, const lzma_index *i) lzma_nothrow;
489
490
491 /**
492  * \brief       Rewind the iterator
493  *
494  * Rewind the iterator so that next call to lzma_index_iter_next() will
495  * return the first Block or Stream.
496  */
497 extern LZMA_API(void) lzma_index_iter_rewind(lzma_index_iter *iter)
498                 lzma_nothrow;
499
500
501 /**
502  * \brief       Get the next Block or Stream
503  *
504  * \param       iter    Iterator initialized with lzma_index_iter_init()
505  * \param       mode    Specify what kind of information the caller wants
506  *                      to get. See lzma_index_iter_mode for details.
507  *
508  * \return      If next Block or Stream matching the mode was found, *iter
509  *              is updated and this function returns false. If no Block or
510  *              Stream matching the mode is found, *iter is not modified
511  *              and this function returns true. If mode is set to an unknown
512  *              value, *iter is not modified and this function returns true.
513  */
514 extern LZMA_API(lzma_bool) lzma_index_iter_next(
515                 lzma_index_iter *iter, lzma_index_iter_mode mode)
516                 lzma_nothrow lzma_attr_warn_unused_result;
517
518
519 /**
520  * \brief       Locate a Block
521  *
522  * If it is possible to seek in the .xz file, it is possible to parse
523  * the Index field(s) and use lzma_index_iter_locate() to do random-access
524  * reading with granularity of Block size.
525  *
526  * \param       iter    Iterator that was earlier initialized with
527  *                      lzma_index_iter_init().
528  * \param       target  Uncompressed target offset which the caller would
529  *                      like to locate from the Stream
530  *
531  * If the target is smaller than the uncompressed size of the Stream (can be
532  * checked with lzma_index_uncompressed_size()):
533  *  - Information about the Stream and Block containing the requested
534  *    uncompressed offset is stored into *iter.
535  *  - Internal state of the iterator is adjusted so that
536  *    lzma_index_iter_next() can be used to read subsequent Blocks or Streams.
537  *  - This function returns false.
538  *
539  * If target is greater than the uncompressed size of the Stream, *iter
540  * is not modified, and this function returns true.
541  */
542 extern LZMA_API(lzma_bool) lzma_index_iter_locate(
543                 lzma_index_iter *iter, lzma_vli target) lzma_nothrow;
544
545
546 /**
547  * \brief       Concatenate lzma_indexes
548  *
549  * Concatenating lzma_indexes is useful when doing random-access reading in
550  * multi-Stream .xz file, or when combining multiple Streams into single
551  * Stream.
552  *
553  * \param       dest      lzma_index after which src is appended
554  * \param       src       lzma_index to be appended after dest. If this
555  *                        function succeeds, the memory allocated for src
556  *                        is freed or moved to be part of dest, and all
557  *                        iterators pointing to src will become invalid.
558  * \param       allocator Custom memory allocator; can be NULL to use
559  *                        malloc() and free().
560  *
561  * \return      - LZMA_OK: lzma_indexes were concatenated successfully.
562  *                src is now a dangling pointer.
563  *              - LZMA_DATA_ERROR: *dest would grow too big.
564  *              - LZMA_MEM_ERROR
565  *              - LZMA_PROG_ERROR
566  */
567 extern LZMA_API(lzma_ret) lzma_index_cat(lzma_index *dest, lzma_index *src,
568                 const lzma_allocator *allocator)
569                 lzma_nothrow lzma_attr_warn_unused_result;
570
571
572 /**
573  * \brief       Duplicate lzma_index
574  *
575  * \return      A copy of the lzma_index, or NULL if memory allocation failed.
576  */
577 extern LZMA_API(lzma_index *) lzma_index_dup(
578                 const lzma_index *i, const lzma_allocator *allocator)
579                 lzma_nothrow lzma_attr_warn_unused_result;
580
581
582 /**
583  * \brief       Initialize .xz Index encoder
584  *
585  * \param       strm        Pointer to properly prepared lzma_stream
586  * \param       i           Pointer to lzma_index which should be encoded.
587  *
588  * The valid `action' values for lzma_code() are LZMA_RUN and LZMA_FINISH.
589  * It is enough to use only one of them (you can choose freely; use LZMA_RUN
590  * to support liblzma versions older than 5.0.0).
591  *
592  * \return      - LZMA_OK: Initialization succeeded, continue with lzma_code().
593  *              - LZMA_MEM_ERROR
594  *              - LZMA_PROG_ERROR
595  */
596 extern LZMA_API(lzma_ret) lzma_index_encoder(
597                 lzma_stream *strm, const lzma_index *i)
598                 lzma_nothrow lzma_attr_warn_unused_result;
599
600
601 /**
602  * \brief       Initialize .xz Index decoder
603  *
604  * \param       strm        Pointer to properly prepared lzma_stream
605  * \param       i           The decoded Index will be made available via
606  *                          this pointer. Initially this function will
607  *                          set *i to NULL (the old value is ignored). If
608  *                          decoding succeeds (lzma_code() returns
609  *                          LZMA_STREAM_END), *i will be set to point
610  *                          to a new lzma_index, which the application
611  *                          has to later free with lzma_index_end().
612  * \param       memlimit    How much memory the resulting lzma_index is
613  *                          allowed to require.
614  *
615  * The valid `action' values for lzma_code() are LZMA_RUN and LZMA_FINISH.
616  * It is enough to use only one of them (you can choose freely; use LZMA_RUN
617  * to support liblzma versions older than 5.0.0).
618  *
619  * \return      - LZMA_OK: Initialization succeeded, continue with lzma_code().
620  *              - LZMA_MEM_ERROR
621  *              - LZMA_MEMLIMIT_ERROR
622  *              - LZMA_PROG_ERROR
623  */
624 extern LZMA_API(lzma_ret) lzma_index_decoder(
625                 lzma_stream *strm, lzma_index **i, uint64_t memlimit)
626                 lzma_nothrow lzma_attr_warn_unused_result;
627
628
629 /**
630  * \brief       Single-call .xz Index encoder
631  *
632  * \param       i         lzma_index to be encoded
633  * \param       out       Beginning of the output buffer
634  * \param       out_pos   The next byte will be written to out[*out_pos].
635  *                        *out_pos is updated only if encoding succeeds.
636  * \param       out_size  Size of the out buffer; the first byte into
637  *                        which no data is written to is out[out_size].
638  *
639  * \return      - LZMA_OK: Encoding was successful.
640  *              - LZMA_BUF_ERROR: Output buffer is too small. Use
641  *                lzma_index_size() to find out how much output
642  *                space is needed.
643  *              - LZMA_PROG_ERROR
644  *
645  * \note        This function doesn't take allocator argument since all
646  *              the internal data is allocated on stack.
647  */
648 extern LZMA_API(lzma_ret) lzma_index_buffer_encode(const lzma_index *i,
649                 uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow;
650
651
652 /**
653  * \brief       Single-call .xz Index decoder
654  *
655  * \param       i           If decoding succeeds, *i will point to a new
656  *                          lzma_index, which the application has to
657  *                          later free with lzma_index_end(). If an error
658  *                          occurs, *i will be NULL. The old value of *i
659  *                          is always ignored and thus doesn't need to be
660  *                          initialized by the caller.
661  * \param       memlimit    Pointer to how much memory the resulting
662  *                          lzma_index is allowed to require. The value
663  *                          pointed by this pointer is modified if and only
664  *                          if LZMA_MEMLIMIT_ERROR is returned.
665  * \param       allocator   Pointer to lzma_allocator, or NULL to use malloc()
666  * \param       in          Beginning of the input buffer
667  * \param       in_pos      The next byte will be read from in[*in_pos].
668  *                          *in_pos is updated only if decoding succeeds.
669  * \param       in_size     Size of the input buffer; the first byte that
670  *                          won't be read is in[in_size].
671  *
672  * \return      - LZMA_OK: Decoding was successful.
673  *              - LZMA_MEM_ERROR
674  *              - LZMA_MEMLIMIT_ERROR: Memory usage limit was reached.
675  *                The minimum required memlimit value was stored to *memlimit.
676  *              - LZMA_DATA_ERROR
677  *              - LZMA_PROG_ERROR
678  */
679 extern LZMA_API(lzma_ret) lzma_index_buffer_decode(lzma_index **i,
680                 uint64_t *memlimit, const lzma_allocator *allocator,
681                 const uint8_t *in, size_t *in_pos, size_t in_size)
682                 lzma_nothrow;