contrib/xz/src/liblzma/api/lzma/filter.h

   1 /**
   2  * \file        lzma/filter.h
   3  * \brief       Common filter related types and functions
   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       Maximum number of filters in a chain
  22  *
  23  * A filter chain can have 1-4 filters, of which three are allowed to change
  24  * the size of the data. Usually only one or two filters are needed.
  25  */
  26 #define LZMA_FILTERS_MAX 4
  27
  28
  29 /**
  30  * \brief       Filter options
  31  *
  32  * This structure is used to pass Filter ID and a pointer filter's
  33  * options to liblzma. A few functions work with a single lzma_filter
  34  * structure, while most functions expect a filter chain.
  35  *
  36  * A filter chain is indicated with an array of lzma_filter structures.
  37  * The array is terminated with .id = LZMA_VLI_UNKNOWN. Thus, the filter
  38  * array must have LZMA_FILTERS_MAX + 1 elements (that is, five) to
  39  * be able to hold any arbitrary filter chain. This is important when
  40  * using lzma_block_header_decode() from block.h, because too small
  41  * array would make liblzma write past the end of the filters array.
  42  */
  43 typedef struct {
  44         /**
  45          * \brief       Filter ID
  46          *
  47          * Use constants whose name begin with `LZMA_FILTER_' to specify
  48          * different filters. In an array of lzma_filter structures, use
  49          * LZMA_VLI_UNKNOWN to indicate end of filters.
  50          *
  51          * \note        This is not an enum, because on some systems enums
  52          *              cannot be 64-bit.
  53          */
  54         lzma_vli id;
  55
  56         /**
  57          * \brief       Pointer to filter-specific options structure
  58          *
  59          * If the filter doesn't need options, set this to NULL. If id is
  60          * set to LZMA_VLI_UNKNOWN, options is ignored, and thus
  61          * doesn't need be initialized.
  62          */
  63         void *options;
  64
  65 } lzma_filter;
  66
  67
  68 /**
  69  * \brief       Test if the given Filter ID is supported for encoding
  70  *
  71  * Return true if the give Filter ID is supported for encoding by this
  72  * liblzma build. Otherwise false is returned.
  73  *
  74  * There is no way to list which filters are available in this particular
  75  * liblzma version and build. It would be useless, because the application
  76  * couldn't know what kind of options the filter would need.
  77  */
  78 extern LZMA_API(lzma_bool) lzma_filter_encoder_is_supported(lzma_vli id)
  79                 lzma_nothrow lzma_attr_const;
  80
  81
  82 /**
  83  * \brief       Test if the given Filter ID is supported for decoding
  84  *
  85  * Return true if the give Filter ID is supported for decoding by this
  86  * liblzma build. Otherwise false is returned.
  87  */
  88 extern LZMA_API(lzma_bool) lzma_filter_decoder_is_supported(lzma_vli id)
  89                 lzma_nothrow lzma_attr_const;
  90
  91
  92 /**
  93  * \brief       Copy the filters array
  94  *
  95  * Copy the Filter IDs and filter-specific options from src to dest.
  96  * Up to LZMA_FILTERS_MAX filters are copied, plus the terminating
  97  * .id == LZMA_VLI_UNKNOWN. Thus, dest should have at least
  98  * LZMA_FILTERS_MAX + 1 elements space unless the caller knows that
  99  * src is smaller than that.
 100  *
 101  * Unless the filter-specific options is NULL, the Filter ID has to be
 102  * supported by liblzma, because liblzma needs to know the size of every
 103  * filter-specific options structure. The filter-specific options are not
 104  * validated. If options is NULL, any unsupported Filter IDs are copied
 105  * without returning an error.
 106  *
 107  * Old filter-specific options in dest are not freed, so dest doesn't
 108  * need to be initialized by the caller in any way.
 109  *
 110  * If an error occurs, memory possibly already allocated by this function
 111  * is always freed.
 112  *
 113  * \return      - LZMA_OK
 114  *              - LZMA_MEM_ERROR
 115  *              - LZMA_OPTIONS_ERROR: Unsupported Filter ID and its options
 116  *                is not NULL.
 117  *              - LZMA_PROG_ERROR: src or dest is NULL.
 118  */
 119 extern LZMA_API(lzma_ret) lzma_filters_copy(const lzma_filter *src,
 120                 lzma_filter *dest, lzma_allocator *allocator) lzma_nothrow;
 121
 122
 123 /**
 124  * \brief       Calculate approximate memory requirements for raw encoder
 125  *
 126  * This function can be used to calculate the memory requirements for
 127  * Block and Stream encoders too because Block and Stream encoders don't
 128  * need significantly more memory than raw encoder.
 129  *
 130  * \param       filters     Array of filters terminated with
 131  *                          .id == LZMA_VLI_UNKNOWN.
 132  *
 133  * \return      Number of bytes of memory required for the given
 134  *              filter chain when encoding. If an error occurs,
 135  *              for example due to unsupported filter chain,
 136  *              UINT64_MAX is returned.
 137  */
 138 extern LZMA_API(uint64_t) lzma_raw_encoder_memusage(const lzma_filter *filters)
 139                 lzma_nothrow lzma_attr_pure;
 140
 141
 142 /**
 143  * \brief       Calculate approximate memory requirements for raw decoder
 144  *
 145  * This function can be used to calculate the memory requirements for
 146  * Block and Stream decoders too because Block and Stream decoders don't
 147  * need significantly more memory than raw decoder.
 148  *
 149  * \param       filters     Array of filters terminated with
 150  *                          .id == LZMA_VLI_UNKNOWN.
 151  *
 152  * \return      Number of bytes of memory required for the given
 153  *              filter chain when decoding. If an error occurs,
 154  *              for example due to unsupported filter chain,
 155  *              UINT64_MAX is returned.
 156  */
 157 extern LZMA_API(uint64_t) lzma_raw_decoder_memusage(const lzma_filter *filters)
 158                 lzma_nothrow lzma_attr_pure;
 159
 160
 161 /**
 162  * \brief       Initialize raw encoder
 163  *
 164  * This function may be useful when implementing custom file formats.
 165  *
 166  * \param       strm    Pointer to properly prepared lzma_stream
 167  * \param       filters Array of lzma_filter structures. The end of the
 168  *                      array must be marked with .id = LZMA_VLI_UNKNOWN.
 169  *
 170  * The `action' with lzma_code() can be LZMA_RUN, LZMA_SYNC_FLUSH (if the
 171  * filter chain supports it), or LZMA_FINISH.
 172  *
 173  * \return      - LZMA_OK
 174  *              - LZMA_MEM_ERROR
 175  *              - LZMA_OPTIONS_ERROR
 176  *              - LZMA_PROG_ERROR
 177  */
 178 extern LZMA_API(lzma_ret) lzma_raw_encoder(
 179                 lzma_stream *strm, const lzma_filter *filters)
 180                 lzma_nothrow lzma_attr_warn_unused_result;
 181
 182
 183 /**
 184  * \brief       Initialize raw decoder
 185  *
 186  * The initialization of raw decoder goes similarly to raw encoder.
 187  *
 188  * The `action' with lzma_code() can be LZMA_RUN or LZMA_FINISH. Using
 189  * LZMA_FINISH is not required, it is supported just for convenience.
 190  *
 191  * \return      - LZMA_OK
 192  *              - LZMA_MEM_ERROR
 193  *              - LZMA_OPTIONS_ERROR
 194  *              - LZMA_PROG_ERROR
 195  */
 196 extern LZMA_API(lzma_ret) lzma_raw_decoder(
 197                 lzma_stream *strm, const lzma_filter *filters)
 198                 lzma_nothrow lzma_attr_warn_unused_result;
 199
 200
 201 /**
 202  * \brief       Update the filter chain in the encoder
 203  *
 204  * This function is for advanced users only. This function has two slightly
 205  * different purposes:
 206  *
 207  *  - After LZMA_FULL_FLUSH when using Stream encoder: Set a new filter
 208  *    chain, which will be used starting from the next Block.
 209  *
 210  *  - After LZMA_SYNC_FLUSH using Raw, Block, or Stream encoder: Change
 211  *    the filter-specific options in the middle of encoding. The actual
 212  *    filters in the chain (Filter IDs) cannot be changed. In the future,
 213  *    it might become possible to change the filter options without
 214  *    using LZMA_SYNC_FLUSH.
 215  *
 216  * While rarely useful, this function may be called also when no data has
 217  * been compressed yet. In that case, this function will behave as if
 218  * LZMA_FULL_FLUSH (Stream encoder) or LZMA_SYNC_FLUSH (Raw or Block
 219  * encoder) had been used right before calling this function.
 220  *
 221  * \return      - LZMA_OK
 222  *              - LZMA_MEM_ERROR
 223  *              - LZMA_MEMLIMIT_ERROR
 224  *              - LZMA_OPTIONS_ERROR
 225  *              - LZMA_PROG_ERROR
 226  */
 227 extern LZMA_API(lzma_ret) lzma_filters_update(
 228                 lzma_stream *strm, const lzma_filter *filters) lzma_nothrow;
 229
 230
 231 /**
 232  * \brief       Single-call raw encoder
 233  *
 234  * \param       filters     Array of lzma_filter structures. The end of the
 235  *                          array must be marked with .id = LZMA_VLI_UNKNOWN.
 236  * \param       allocator   lzma_allocator for custom allocator functions.
 237  *                          Set to NULL to use malloc() and free().
 238  * \param       in          Beginning of the input buffer
 239  * \param       in_size     Size of the input buffer
 240  * \param       out         Beginning of the output buffer
 241  * \param       out_pos     The next byte will be written to out[*out_pos].
 242  *                          *out_pos is updated only if encoding succeeds.
 243  * \param       out_size    Size of the out buffer; the first byte into
 244  *                          which no data is written to is out[out_size].
 245  *
 246  * \return      - LZMA_OK: Encoding was successful.
 247  *              - LZMA_BUF_ERROR: Not enough output buffer space.
 248  *              - LZMA_OPTIONS_ERROR
 249  *              - LZMA_MEM_ERROR
 250  *              - LZMA_DATA_ERROR
 251  *              - LZMA_PROG_ERROR
 252  *
 253  * \note        There is no function to calculate how big output buffer
 254  *              would surely be big enough. (lzma_stream_buffer_bound()
 255  *              works only for lzma_stream_buffer_encode(); raw encoder
 256  *              won't necessarily meet that bound.)
 257  */
 258 extern LZMA_API(lzma_ret) lzma_raw_buffer_encode(
 259                 const lzma_filter *filters, lzma_allocator *allocator,
 260                 const uint8_t *in, size_t in_size, uint8_t *out,
 261                 size_t *out_pos, size_t out_size) lzma_nothrow;
 262
 263
 264 /**
 265  * \brief       Single-call raw decoder
 266  *
 267  * \param       filters     Array of lzma_filter structures. The end of the
 268  *                          array must be marked with .id = LZMA_VLI_UNKNOWN.
 269  * \param       allocator   lzma_allocator for custom allocator functions.
 270  *                          Set to NULL to use malloc() and free().
 271  * \param       in          Beginning of the input buffer
 272  * \param       in_pos      The next byte will be read from in[*in_pos].
 273  *                          *in_pos is updated only if decoding succeeds.
 274  * \param       in_size     Size of the input buffer; the first byte that
 275  *                          won't be read is in[in_size].
 276  * \param       out         Beginning of the output buffer
 277  * \param       out_pos     The next byte will be written to out[*out_pos].
 278  *                          *out_pos is updated only if encoding succeeds.
 279  * \param       out_size    Size of the out buffer; the first byte into
 280  *                          which no data is written to is out[out_size].
 281  */
 282 extern LZMA_API(lzma_ret) lzma_raw_buffer_decode(
 283                 const lzma_filter *filters, lzma_allocator *allocator,
 284                 const uint8_t *in, size_t *in_pos, size_t in_size,
 285                 uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow;
 286
 287
 288 /**
 289  * \brief       Get the size of the Filter Properties field
 290  *
 291  * This function may be useful when implementing custom file formats
 292  * using the raw encoder and decoder.
 293  *
 294  * \param       size    Pointer to uint32_t to hold the size of the properties
 295  * \param       filter  Filter ID and options (the size of the properties may
 296  *                      vary depending on the options)
 297  *
 298  * \return      - LZMA_OK
 299  *              - LZMA_OPTIONS_ERROR
 300  *              - LZMA_PROG_ERROR
 301  *
 302  * \note        This function validates the Filter ID, but does not
 303  *              necessarily validate the options. Thus, it is possible
 304  *              that this returns LZMA_OK while the following call to
 305  *              lzma_properties_encode() returns LZMA_OPTIONS_ERROR.
 306  */
 307 extern LZMA_API(lzma_ret) lzma_properties_size(
 308                 uint32_t *size, const lzma_filter *filter) lzma_nothrow;
 309
 310
 311 /**
 312  * \brief       Encode the Filter Properties field
 313  *
 314  * \param       filter  Filter ID and options
 315  * \param       props   Buffer to hold the encoded options. The size of
 316  *                      buffer must have been already determined with
 317  *                      lzma_properties_size().
 318  *
 319  * \return      - LZMA_OK
 320  *              - LZMA_OPTIONS_ERROR
 321  *              - LZMA_PROG_ERROR
 322  *
 323  * \note        Even this function won't validate more options than actually
 324  *              necessary. Thus, it is possible that encoding the properties
 325  *              succeeds but using the same options to initialize the encoder
 326  *              will fail.
 327  *
 328  * \note        If lzma_properties_size() indicated that the size
 329  *              of the Filter Properties field is zero, calling
 330  *              lzma_properties_encode() is not required, but it
 331  *              won't do any harm either.
 332  */
 333 extern LZMA_API(lzma_ret) lzma_properties_encode(
 334                 const lzma_filter *filter, uint8_t *props) lzma_nothrow;
 335
 336
 337 /**
 338  * \brief       Decode the Filter Properties field
 339  *
 340  * \param       filter      filter->id must have been set to the correct
 341  *                          Filter ID. filter->options doesn't need to be
 342  *                          initialized (it's not freed by this function). The
 343  *                          decoded options will be stored to filter->options.
 344  *                          filter->options is set to NULL if there are no
 345  *                          properties or if an error occurs.
 346  * \param       allocator   Custom memory allocator used to allocate the
 347  *                          options. Set to NULL to use the default malloc(),
 348  *                          and in case of an error, also free().
 349  * \param       props       Input buffer containing the properties.
 350  * \param       props_size  Size of the properties. This must be the exact
 351  *                          size; giving too much or too little input will
 352  *                          return LZMA_OPTIONS_ERROR.
 353  *
 354  * \return      - LZMA_OK
 355  *              - LZMA_OPTIONS_ERROR
 356  *              - LZMA_MEM_ERROR
 357  */
 358 extern LZMA_API(lzma_ret) lzma_properties_decode(
 359                 lzma_filter *filter, lzma_allocator *allocator,
 360                 const uint8_t *props, size_t props_size) lzma_nothrow;
 361
 362
 363 /**
 364  * \brief       Calculate encoded size of a Filter Flags field
 365  *
 366  * Knowing the size of Filter Flags is useful to know when allocating
 367  * memory to hold the encoded Filter Flags.
 368  *
 369  * \param       size    Pointer to integer to hold the calculated size
 370  * \param       filter  Filter ID and associated options whose encoded
 371  *                      size is to be calculated
 372  *
 373  * \return      - LZMA_OK: *size set successfully. Note that this doesn't
 374  *                guarantee that filter->options is valid, thus
 375  *                lzma_filter_flags_encode() may still fail.
 376  *              - LZMA_OPTIONS_ERROR: Unknown Filter ID or unsupported options.
 377  *              - LZMA_PROG_ERROR: Invalid options
 378  *
 379  * \note        If you need to calculate size of List of Filter Flags,
 380  *              you need to loop over every lzma_filter entry.
 381  */
 382 extern LZMA_API(lzma_ret) lzma_filter_flags_size(
 383                 uint32_t *size, const lzma_filter *filter)
 384                 lzma_nothrow lzma_attr_warn_unused_result;
 385
 386
 387 /**
 388  * \brief       Encode Filter Flags into given buffer
 389  *
 390  * In contrast to some functions, this doesn't allocate the needed buffer.
 391  * This is due to how this function is used internally by liblzma.
 392  *
 393  * \param       filter      Filter ID and options to be encoded
 394  * \param       out         Beginning of the output buffer
 395  * \param       out_pos     out[*out_pos] is the next write position. This
 396  *                          is updated by the encoder.
 397  * \param       out_size    out[out_size] is the first byte to not write.
 398  *
 399  * \return      - LZMA_OK: Encoding was successful.
 400  *              - LZMA_OPTIONS_ERROR: Invalid or unsupported options.
 401  *              - LZMA_PROG_ERROR: Invalid options or not enough output
 402  *                buffer space (you should have checked it with
 403  *                lzma_filter_flags_size()).
 404  */
 405 extern LZMA_API(lzma_ret) lzma_filter_flags_encode(const lzma_filter *filter,
 406                 uint8_t *out, size_t *out_pos, size_t out_size)
 407                 lzma_nothrow lzma_attr_warn_unused_result;
 408
 409
 410 /**
 411  * \brief       Decode Filter Flags from given buffer
 412  *
 413  * The decoded result is stored into *filter. The old value of
 414  * filter->options is not free()d.
 415  *
 416  * \return      - LZMA_OK
 417  *              - LZMA_OPTIONS_ERROR
 418  *              - LZMA_MEM_ERROR
 419  *              - LZMA_PROG_ERROR
 420  */
 421 extern LZMA_API(lzma_ret) lzma_filter_flags_decode(
 422                 lzma_filter *filter, lzma_allocator *allocator,
 423                 const uint8_t *in, size_t *in_pos, size_t in_size)
 424                 lzma_nothrow lzma_attr_warn_unused_result;