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