1 /** 2 * \file lzma/block.h 3 * \brief .xz Block handling 4 * \note Never include this file directly. Use <lzma.h> instead. 5 */ 6 7 /* 8 * Author: Lasse Collin 9 * 10 * This file has been put into the public domain. 11 * You can do whatever you want with this file. 12 */ 13 14 #ifndef LZMA_H_INTERNAL 15 # error Never include this file directly. Use <lzma.h> instead. 16 #endif 17 18 19 /** 20 * \brief Options for the Block and Block Header encoders and decoders 21 * 22 * Different Block handling functions use different parts of this structure. 23 * Some read some members, other functions write, and some do both. Only the 24 * members listed for reading need to be initialized when the specified 25 * functions are called. The members marked for writing will be assigned 26 * new values at some point either by calling the given function or by 27 * later calls to lzma_code(). 28 */ 29 typedef struct { 30 /** 31 * \brief Block format version 32 * 33 * To prevent API and ABI breakages when new features are needed, 34 * a version number is used to indicate which members in this 35 * structure are in use: 36 * - liblzma >= 5.0.0: version = 0 is supported. 37 * - liblzma >= 5.1.4beta: Support for version = 1 was added, 38 * which adds the ignore_check member. 39 * 40 * If version is greater than one, most Block related functions 41 * will return LZMA_OPTIONS_ERROR (lzma_block_header_decode() works 42 * with any version value). 43 * 44 * Read by: 45 * - lzma_block_header_size() 46 * - lzma_block_header_encode() 47 * - lzma_block_header_decode() 48 * - lzma_block_compressed_size() 49 * - lzma_block_unpadded_size() 50 * - lzma_block_total_size() 51 * - lzma_block_encoder() 52 * - lzma_block_decoder() 53 * - lzma_block_buffer_encode() 54 * - lzma_block_uncomp_encode() 55 * - lzma_block_buffer_decode() 56 * 57 * Written by: 58 * - lzma_block_header_decode() 59 */ 60 uint32_t version; 61 62 /** 63 * \brief Size of the Block Header field in bytes 64 * 65 * This is always a multiple of four. 66 * 67 * Read by: 68 * - lzma_block_header_encode() 69 * - lzma_block_header_decode() 70 * - lzma_block_compressed_size() 71 * - lzma_block_unpadded_size() 72 * - lzma_block_total_size() 73 * - lzma_block_decoder() 74 * - lzma_block_buffer_decode() 75 * 76 * Written by: 77 * - lzma_block_header_size() 78 * - lzma_block_buffer_encode() 79 * - lzma_block_uncomp_encode() 80 */ 81 uint32_t header_size; 82 # define LZMA_BLOCK_HEADER_SIZE_MIN 8 83 # define LZMA_BLOCK_HEADER_SIZE_MAX 1024 84 85 /** 86 * \brief Type of integrity Check 87 * 88 * The Check ID is not stored into the Block Header, thus its value 89 * must be provided also when decoding. 90 * 91 * Read by: 92 * - lzma_block_header_encode() 93 * - lzma_block_header_decode() 94 * - lzma_block_compressed_size() 95 * - lzma_block_unpadded_size() 96 * - lzma_block_total_size() 97 * - lzma_block_encoder() 98 * - lzma_block_decoder() 99 * - lzma_block_buffer_encode() 100 * - lzma_block_buffer_decode() 101 */ 102 lzma_check check; 103 104 /** 105 * \brief Size of the Compressed Data in bytes 106 * 107 * Encoding: If this is not LZMA_VLI_UNKNOWN, Block Header encoder 108 * will store this value to the Block Header. Block encoder doesn't 109 * care about this value, but will set it once the encoding has been 110 * finished. 111 * 112 * Decoding: If this is not LZMA_VLI_UNKNOWN, Block decoder will 113 * verify that the size of the Compressed Data field matches 114 * compressed_size. 115 * 116 * Usually you don't know this value when encoding in streamed mode, 117 * and thus cannot write this field into the Block Header. 118 * 119 * In non-streamed mode you can reserve space for this field before 120 * encoding the actual Block. After encoding the data, finish the 121 * Block by encoding the Block Header. Steps in detail: 122 * 123 * - Set compressed_size to some big enough value. If you don't know 124 * better, use LZMA_VLI_MAX, but remember that bigger values take 125 * more space in Block Header. 126 * 127 * - Call lzma_block_header_size() to see how much space you need to 128 * reserve for the Block Header. 129 * 130 * - Encode the Block using lzma_block_encoder() and lzma_code(). 131 * It sets compressed_size to the correct value. 132 * 133 * - Use lzma_block_header_encode() to encode the Block Header. 134 * Because space was reserved in the first step, you don't need 135 * to call lzma_block_header_size() anymore, because due to 136 * reserving, header_size has to be big enough. If it is "too big", 137 * lzma_block_header_encode() will add enough Header Padding to 138 * make Block Header to match the size specified by header_size. 139 * 140 * Read by: 141 * - lzma_block_header_size() 142 * - lzma_block_header_encode() 143 * - lzma_block_compressed_size() 144 * - lzma_block_unpadded_size() 145 * - lzma_block_total_size() 146 * - lzma_block_decoder() 147 * - lzma_block_buffer_decode() 148 * 149 * Written by: 150 * - lzma_block_header_decode() 151 * - lzma_block_compressed_size() 152 * - lzma_block_encoder() 153 * - lzma_block_decoder() 154 * - lzma_block_buffer_encode() 155 * - lzma_block_uncomp_encode() 156 * - lzma_block_buffer_decode() 157 */ 158 lzma_vli compressed_size; 159 160 /** 161 * \brief Uncompressed Size in bytes 162 * 163 * This is handled very similarly to compressed_size above. 164 * 165 * uncompressed_size is needed by fewer functions than 166 * compressed_size. This is because uncompressed_size isn't 167 * needed to validate that Block stays within proper limits. 168 * 169 * Read by: 170 * - lzma_block_header_size() 171 * - lzma_block_header_encode() 172 * - lzma_block_decoder() 173 * - lzma_block_buffer_decode() 174 * 175 * Written by: 176 * - lzma_block_header_decode() 177 * - lzma_block_encoder() 178 * - lzma_block_decoder() 179 * - lzma_block_buffer_encode() 180 * - lzma_block_uncomp_encode() 181 * - lzma_block_buffer_decode() 182 */ 183 lzma_vli uncompressed_size; 184 185 /** 186 * \brief Array of filters 187 * 188 * There can be 1-4 filters. The end of the array is marked with 189 * .id = LZMA_VLI_UNKNOWN. 190 * 191 * Read by: 192 * - lzma_block_header_size() 193 * - lzma_block_header_encode() 194 * - lzma_block_encoder() 195 * - lzma_block_decoder() 196 * - lzma_block_buffer_encode() 197 * - lzma_block_buffer_decode() 198 * 199 * Written by: 200 * - lzma_block_header_decode(): Note that this does NOT free() 201 * the old filter options structures. All unused filters[] will 202 * have .id == LZMA_VLI_UNKNOWN and .options == NULL. If 203 * decoding fails, all filters[] are guaranteed to be 204 * LZMA_VLI_UNKNOWN and NULL. 205 * 206 * \note Because of the array is terminated with 207 * .id = LZMA_VLI_UNKNOWN, the actual array must 208 * have LZMA_FILTERS_MAX + 1 members or the Block 209 * Header decoder will overflow the buffer. 210 */ 211 lzma_filter *filters; 212 213 /** 214 * \brief Raw value stored in the Check field 215 * 216 * After successful coding, the first lzma_check_size(check) bytes 217 * of this array contain the raw value stored in the Check field. 218 * 219 * Note that CRC32 and CRC64 are stored in little endian byte order. 220 * Take it into account if you display the Check values to the user. 221 * 222 * Written by: 223 * - lzma_block_encoder() 224 * - lzma_block_decoder() 225 * - lzma_block_buffer_encode() 226 * - lzma_block_uncomp_encode() 227 * - lzma_block_buffer_decode() 228 */ 229 uint8_t raw_check[LZMA_CHECK_SIZE_MAX]; 230 231 /* 232 * Reserved space to allow possible future extensions without 233 * breaking the ABI. You should not touch these, because the names 234 * of these variables may change. These are and will never be used 235 * with the currently supported options, so it is safe to leave these 236 * uninitialized. 237 */ 238 239 /** \private Reserved member. */ 240 void *reserved_ptr1; 241 242 /** \private Reserved member. */ 243 void *reserved_ptr2; 244 245 /** \private Reserved member. */ 246 void *reserved_ptr3; 247 248 /** \private Reserved member. */ 249 uint32_t reserved_int1; 250 251 /** \private Reserved member. */ 252 uint32_t reserved_int2; 253 254 /** \private Reserved member. */ 255 lzma_vli reserved_int3; 256 257 /** \private Reserved member. */ 258 lzma_vli reserved_int4; 259 260 /** \private Reserved member. */ 261 lzma_vli reserved_int5; 262 263 /** \private Reserved member. */ 264 lzma_vli reserved_int6; 265 266 /** \private Reserved member. */ 267 lzma_vli reserved_int7; 268 269 /** \private Reserved member. */ 270 lzma_vli reserved_int8; 271 272 /** \private Reserved member. */ 273 lzma_reserved_enum reserved_enum1; 274 275 /** \private Reserved member. */ 276 lzma_reserved_enum reserved_enum2; 277 278 /** \private Reserved member. */ 279 lzma_reserved_enum reserved_enum3; 280 281 /** \private Reserved member. */ 282 lzma_reserved_enum reserved_enum4; 283 284 /** 285 * \brief A flag to Block decoder to not verify the Check field 286 * 287 * This member is supported by liblzma >= 5.1.4beta if .version >= 1. 288 * 289 * If this is set to true, the integrity check won't be calculated 290 * and verified. Unless you know what you are doing, you should 291 * leave this to false. (A reason to set this to true is when the 292 * file integrity is verified externally anyway and you want to 293 * speed up the decompression, which matters mostly when using 294 * SHA-256 as the integrity check.) 295 * 296 * If .version >= 1, read by: 297 * - lzma_block_decoder() 298 * - lzma_block_buffer_decode() 299 * 300 * Written by (.version is ignored): 301 * - lzma_block_header_decode() always sets this to false 302 */ 303 lzma_bool ignore_check; 304 305 /** \private Reserved member. */ 306 lzma_bool reserved_bool2; 307 308 /** \private Reserved member. */ 309 lzma_bool reserved_bool3; 310 311 /** \private Reserved member. */ 312 lzma_bool reserved_bool4; 313 314 /** \private Reserved member. */ 315 lzma_bool reserved_bool5; 316 317 /** \private Reserved member. */ 318 lzma_bool reserved_bool6; 319 320 /** \private Reserved member. */ 321 lzma_bool reserved_bool7; 322 323 /** \private Reserved member. */ 324 lzma_bool reserved_bool8; 325 326 } lzma_block; 327 328 329 /** 330 * \brief Decode the Block Header Size field 331 * 332 * To decode Block Header using lzma_block_header_decode(), the size of the 333 * Block Header has to be known and stored into lzma_block.header_size. 334 * The size can be calculated from the first byte of a Block using this macro. 335 * Note that if the first byte is 0x00, it indicates beginning of Index; use 336 * this macro only when the byte is not 0x00. 337 * 338 * There is no encoding macro because lzma_block_header_size() and 339 * lzma_block_header_encode() should be used. 340 */ 341 #define lzma_block_header_size_decode(b) (((uint32_t)(b) + 1) * 4) 342 343 344 /** 345 * \brief Calculate Block Header Size 346 * 347 * Calculate the minimum size needed for the Block Header field using the 348 * settings specified in the lzma_block structure. Note that it is OK to 349 * increase the calculated header_size value as long as it is a multiple of 350 * four and doesn't exceed LZMA_BLOCK_HEADER_SIZE_MAX. Increasing header_size 351 * just means that lzma_block_header_encode() will add Header Padding. 352 * 353 * \note This doesn't check that all the options are valid i.e. this 354 * may return LZMA_OK even if lzma_block_header_encode() or 355 * lzma_block_encoder() would fail. If you want to validate the 356 * filter chain, consider using lzma_memlimit_encoder() which as 357 * a side-effect validates the filter chain. 358 * 359 * \param block Block options 360 * 361 * \return Possible lzma_ret values: 362 * - LZMA_OK: Size calculated successfully and stored to 363 * block->header_size. 364 * - LZMA_OPTIONS_ERROR: Unsupported version, filters or 365 * filter options. 366 * - LZMA_PROG_ERROR: Invalid values like compressed_size == 0. 367 */ 368 extern LZMA_API(lzma_ret) lzma_block_header_size(lzma_block *block) 369 lzma_nothrow lzma_attr_warn_unused_result; 370 371 372 /** 373 * \brief Encode Block Header 374 * 375 * The caller must have calculated the size of the Block Header already with 376 * lzma_block_header_size(). If a value larger than the one calculated by 377 * lzma_block_header_size() is used, the Block Header will be padded to the 378 * specified size. 379 * 380 * \param block Block options to be encoded. 381 * \param[out] out Beginning of the output buffer. This must be 382 * at least block->header_size bytes. 383 * 384 * \return Possible lzma_ret values: 385 * - LZMA_OK: Encoding was successful. block->header_size 386 * bytes were written to output buffer. 387 * - LZMA_OPTIONS_ERROR: Invalid or unsupported options. 388 * - LZMA_PROG_ERROR: Invalid arguments, for example 389 * block->header_size is invalid or block->filters is NULL. 390 */ 391 extern LZMA_API(lzma_ret) lzma_block_header_encode( 392 const lzma_block *block, uint8_t *out) 393 lzma_nothrow lzma_attr_warn_unused_result; 394 395 396 /** 397 * \brief Decode Block Header 398 * 399 * block->version should (usually) be set to the highest value supported 400 * by the application. If the application sets block->version to a value 401 * higher than supported by the current liblzma version, this function will 402 * downgrade block->version to the highest value supported by it. Thus one 403 * should check the value of block->version after calling this function if 404 * block->version was set to a non-zero value and the application doesn't 405 * otherwise know that the liblzma version being used is new enough to 406 * support the specified block->version. 407 * 408 * The size of the Block Header must have already been decoded with 409 * lzma_block_header_size_decode() macro and stored to block->header_size. 410 * 411 * The integrity check type from Stream Header must have been stored 412 * to block->check. 413 * 414 * block->filters must have been allocated, but they don't need to be 415 * initialized (possible existing filter options are not freed). 416 * 417 * \param[out] block Destination for Block options 418 * \param allocator lzma_allocator for custom allocator functions. 419 * Set to NULL to use malloc() (and also free() 420 * if an error occurs). 421 * \param in Beginning of the input buffer. This must be 422 * at least block->header_size bytes. 423 * 424 * \return Possible lzma_ret values: 425 * - LZMA_OK: Decoding was successful. block->header_size 426 * bytes were read from the input buffer. 427 * - LZMA_OPTIONS_ERROR: The Block Header specifies some 428 * unsupported options such as unsupported filters. This can 429 * happen also if block->version was set to a too low value 430 * compared to what would be required to properly represent 431 * the information stored in the Block Header. 432 * - LZMA_DATA_ERROR: Block Header is corrupt, for example, 433 * the CRC32 doesn't match. 434 * - LZMA_PROG_ERROR: Invalid arguments, for example 435 * block->header_size is invalid or block->filters is NULL. 436 */ 437 extern LZMA_API(lzma_ret) lzma_block_header_decode(lzma_block *block, 438 const lzma_allocator *allocator, const uint8_t *in) 439 lzma_nothrow lzma_attr_warn_unused_result; 440 441 442 /** 443 * \brief Validate and set Compressed Size according to Unpadded Size 444 * 445 * Block Header stores Compressed Size, but Index has Unpadded Size. If the 446 * application has already parsed the Index and is now decoding Blocks, 447 * it can calculate Compressed Size from Unpadded Size. This function does 448 * exactly that with error checking: 449 * 450 * - Compressed Size calculated from Unpadded Size must be positive integer, 451 * that is, Unpadded Size must be big enough that after Block Header and 452 * Check fields there's still at least one byte for Compressed Size. 453 * 454 * - If Compressed Size was present in Block Header, the new value 455 * calculated from Unpadded Size is compared against the value 456 * from Block Header. 457 * 458 * \note This function must be called _after_ decoding the Block Header 459 * field so that it can properly validate Compressed Size if it 460 * was present in Block Header. 461 * 462 * \param block Block options: block->header_size must 463 * already be set with lzma_block_header_size(). 464 * \param unpadded_size Unpadded Size from the Index field in bytes 465 * 466 * \return Possible lzma_ret values: 467 * - LZMA_OK: block->compressed_size was set successfully. 468 * - LZMA_DATA_ERROR: unpadded_size is too small compared to 469 * block->header_size and lzma_check_size(block->check). 470 * - LZMA_PROG_ERROR: Some values are invalid. For example, 471 * block->header_size must be a multiple of four and 472 * between 8 and 1024 inclusive. 473 */ 474 extern LZMA_API(lzma_ret) lzma_block_compressed_size( 475 lzma_block *block, lzma_vli unpadded_size) 476 lzma_nothrow lzma_attr_warn_unused_result; 477 478 479 /** 480 * \brief Calculate Unpadded Size 481 * 482 * The Index field stores Unpadded Size and Uncompressed Size. The latter 483 * can be taken directly from the lzma_block structure after coding a Block, 484 * but Unpadded Size needs to be calculated from Block Header Size, 485 * Compressed Size, and size of the Check field. This is where this function 486 * is needed. 487 * 488 * \param block Block options: block->header_size must already be 489 * set with lzma_block_header_size(). 490 * 491 * \return Unpadded Size on success, or zero on error. 492 */ 493 extern LZMA_API(lzma_vli) lzma_block_unpadded_size(const lzma_block *block) 494 lzma_nothrow lzma_attr_pure; 495 496 497 /** 498 * \brief Calculate the total encoded size of a Block 499 * 500 * This is equivalent to lzma_block_unpadded_size() except that the returned 501 * value includes the size of the Block Padding field. 502 * 503 * \param block Block options: block->header_size must already be 504 * set with lzma_block_header_size(). 505 * 506 * \return On success, total encoded size of the Block. On error, 507 * zero is returned. 508 */ 509 extern LZMA_API(lzma_vli) lzma_block_total_size(const lzma_block *block) 510 lzma_nothrow lzma_attr_pure; 511 512 513 /** 514 * \brief Initialize .xz Block encoder 515 * 516 * Valid actions for lzma_code() are LZMA_RUN, LZMA_SYNC_FLUSH (only if the 517 * filter chain supports it), and LZMA_FINISH. 518 * 519 * The Block encoder encodes the Block Data, Block Padding, and Check value. 520 * It does NOT encode the Block Header which can be encoded with 521 * lzma_block_header_encode(). 522 * 523 * \param strm Pointer to lzma_stream that is at least initialized 524 * with LZMA_STREAM_INIT. 525 * \param block Block options: block->version, block->check, 526 * and block->filters must have been initialized. 527 * 528 * \return Possible lzma_ret values: 529 * - LZMA_OK: All good, continue with lzma_code(). 530 * - LZMA_MEM_ERROR 531 * - LZMA_OPTIONS_ERROR 532 * - LZMA_UNSUPPORTED_CHECK: block->check specifies a Check ID 533 * that is not supported by this build of liblzma. Initializing 534 * the encoder failed. 535 * - LZMA_PROG_ERROR 536 */ 537 extern LZMA_API(lzma_ret) lzma_block_encoder( 538 lzma_stream *strm, lzma_block *block) 539 lzma_nothrow lzma_attr_warn_unused_result; 540 541 542 /** 543 * \brief Initialize .xz Block decoder 544 * 545 * Valid actions for lzma_code() are LZMA_RUN and LZMA_FINISH. Using 546 * LZMA_FINISH is not required. It is supported only for convenience. 547 * 548 * The Block decoder decodes the Block Data, Block Padding, and Check value. 549 * It does NOT decode the Block Header which can be decoded with 550 * lzma_block_header_decode(). 551 * 552 * \param strm Pointer to lzma_stream that is at least initialized 553 * with LZMA_STREAM_INIT. 554 * \param block Block options 555 * 556 * \return Possible lzma_ret values: 557 * - LZMA_OK: All good, continue with lzma_code(). 558 * - LZMA_PROG_ERROR 559 * - LZMA_MEM_ERROR 560 */ 561 extern LZMA_API(lzma_ret) lzma_block_decoder( 562 lzma_stream *strm, lzma_block *block) 563 lzma_nothrow lzma_attr_warn_unused_result; 564 565 566 /** 567 * \brief Calculate maximum output size for single-call Block encoding 568 * 569 * This is equivalent to lzma_stream_buffer_bound() but for .xz Blocks. 570 * See the documentation of lzma_stream_buffer_bound(). 571 * 572 * \param uncompressed_size Size of the data to be encoded with the 573 * single-call Block encoder. 574 * 575 * \return Maximum output size in bytes for single-call Block encoding. 576 */ 577 extern LZMA_API(size_t) lzma_block_buffer_bound(size_t uncompressed_size) 578 lzma_nothrow; 579 580 581 /** 582 * \brief Single-call .xz Block encoder 583 * 584 * In contrast to the multi-call encoder initialized with 585 * lzma_block_encoder(), this function encodes also the Block Header. This 586 * is required to make it possible to write appropriate Block Header also 587 * in case the data isn't compressible, and different filter chain has to be 588 * used to encode the data in uncompressed form using uncompressed chunks 589 * of the LZMA2 filter. 590 * 591 * When the data isn't compressible, header_size, compressed_size, and 592 * uncompressed_size are set just like when the data was compressible, but 593 * it is possible that header_size is too small to hold the filter chain 594 * specified in block->filters, because that isn't necessarily the filter 595 * chain that was actually used to encode the data. lzma_block_unpadded_size() 596 * still works normally, because it doesn't read the filters array. 597 * 598 * \param block Block options: block->version, block->check, 599 * and block->filters must have been initialized. 600 * \param allocator lzma_allocator for custom allocator functions. 601 * Set to NULL to use malloc() and free(). 602 * \param in Beginning of the input buffer 603 * \param in_size Size of the input buffer 604 * \param[out] out Beginning of the output buffer 605 * \param[out] out_pos The next byte will be written to out[*out_pos]. 606 * *out_pos is updated only if encoding succeeds. 607 * \param out_size Size of the out buffer; the first byte into 608 * which no data is written to is out[out_size]. 609 * 610 * \return Possible lzma_ret values: 611 * - LZMA_OK: Encoding was successful. 612 * - LZMA_BUF_ERROR: Not enough output buffer space. 613 * - LZMA_UNSUPPORTED_CHECK 614 * - LZMA_OPTIONS_ERROR 615 * - LZMA_MEM_ERROR 616 * - LZMA_DATA_ERROR 617 * - LZMA_PROG_ERROR 618 */ 619 extern LZMA_API(lzma_ret) lzma_block_buffer_encode( 620 lzma_block *block, const lzma_allocator *allocator, 621 const uint8_t *in, size_t in_size, 622 uint8_t *out, size_t *out_pos, size_t out_size) 623 lzma_nothrow lzma_attr_warn_unused_result; 624 625 626 /** 627 * \brief Single-call uncompressed .xz Block encoder 628 * 629 * This is like lzma_block_buffer_encode() except this doesn't try to 630 * compress the data and instead encodes the data using LZMA2 uncompressed 631 * chunks. The required output buffer size can be determined with 632 * lzma_block_buffer_bound(). 633 * 634 * Since the data won't be compressed, this function ignores block->filters. 635 * This function doesn't take lzma_allocator because this function doesn't 636 * allocate any memory from the heap. 637 * 638 * \param block Block options: block->version, block->check, 639 * and block->filters must have been initialized. 640 * \param in Beginning of the input buffer 641 * \param in_size Size of the input buffer 642 * \param[out] out Beginning of the output buffer 643 * \param[out] out_pos The next byte will be written to out[*out_pos]. 644 * *out_pos is updated only if encoding succeeds. 645 * \param out_size Size of the out buffer; the first byte into 646 * which no data is written to is out[out_size]. 647 * 648 * \return Possible lzma_ret values: 649 * - LZMA_OK: Encoding was successful. 650 * - LZMA_BUF_ERROR: Not enough output buffer space. 651 * - LZMA_UNSUPPORTED_CHECK 652 * - LZMA_OPTIONS_ERROR 653 * - LZMA_MEM_ERROR 654 * - LZMA_DATA_ERROR 655 * - LZMA_PROG_ERROR 656 */ 657 extern LZMA_API(lzma_ret) lzma_block_uncomp_encode(lzma_block *block, 658 const uint8_t *in, size_t in_size, 659 uint8_t *out, size_t *out_pos, size_t out_size) 660 lzma_nothrow lzma_attr_warn_unused_result; 661 662 663 /** 664 * \brief Single-call .xz Block decoder 665 * 666 * This is single-call equivalent of lzma_block_decoder(), and requires that 667 * the caller has already decoded Block Header and checked its memory usage. 668 * 669 * \param block Block options 670 * \param allocator lzma_allocator for custom allocator functions. 671 * Set to NULL to use malloc() and free(). 672 * \param in Beginning of the input buffer 673 * \param in_pos The next byte will be read from in[*in_pos]. 674 * *in_pos is updated only if decoding succeeds. 675 * \param in_size Size of the input buffer; the first byte that 676 * won't be read is in[in_size]. 677 * \param[out] out Beginning of the output buffer 678 * \param[out] out_pos The next byte will be written to out[*out_pos]. 679 * *out_pos is updated only if encoding succeeds. 680 * \param out_size Size of the out buffer; the first byte into 681 * which no data is written to is out[out_size]. 682 * 683 * \return Possible lzma_ret values: 684 * - LZMA_OK: Decoding was successful. 685 * - LZMA_OPTIONS_ERROR 686 * - LZMA_DATA_ERROR 687 * - LZMA_MEM_ERROR 688 * - LZMA_BUF_ERROR: Output buffer was too small. 689 * - LZMA_PROG_ERROR 690 */ 691 extern LZMA_API(lzma_ret) lzma_block_buffer_decode( 692 lzma_block *block, const lzma_allocator *allocator, 693 const uint8_t *in, size_t *in_pos, size_t in_size, 694 uint8_t *out, size_t *out_pos, size_t out_size) 695 lzma_nothrow; 696