root / lab4 / .minix-src / include / lzma / index.h @ 14
History | View | Annotate | Download (22.7 KB)
| 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; |