lz_decoder.h

Go to the documentation of this file.

// SPDX-License-Identifier: 0BSD
 
//
//  Authors:    Igor Pavlov
//              Lasse Collin
//
 
#ifndef LZMA_LZ_DECODER_H
#define LZMA_LZ_DECODER_H
 
#include "common.h"
 
 
#define LZ_DICT_REPEAT_MAX 288
 
 
typedef struct {
    uint8_t *buf;
 
    size_t pos;
 
    size_t full;
 
    size_t limit;
 
    size_t size;
 
    bool has_wrapped;
 
    bool need_reset;
 
} lzma_dict;
 
 
typedef struct {
    size_t dict_size;
    const uint8_t *preset_dict;
    size_t preset_dict_size;
} lzma_lz_options;
 
 
typedef struct {
    void *coder;
 
    lzma_ret (*code)(void *coder,
            lzma_dict *restrict dict, const uint8_t *restrict in,
            size_t *restrict in_pos, size_t in_size);
 
    void (*reset)(void *coder, const void *options);
 
    void (*set_uncompressed)(void *coder, lzma_vli uncompressed_size,
            bool allow_eopm);
 
    void (*end)(void *coder, const lzma_allocator *allocator);
 
} lzma_lz_decoder;
 
 
#define LZMA_LZ_DECODER_INIT \
    (lzma_lz_decoder){ \
        .coder = NULL, \
        .code = NULL, \
        .reset = NULL, \
        .set_uncompressed = NULL, \
        .end = NULL, \
    }
 
 
extern lzma_ret lzma_lz_decoder_init(lzma_next_coder *next,
        const lzma_allocator *allocator,
        const lzma_filter_info *filters,
        lzma_ret (*lz_init)(lzma_lz_decoder *lz,
            const lzma_allocator *allocator,
            lzma_vli id, const void *options,
            lzma_lz_options *lz_options));
 
extern uint64_t lzma_lz_decoder_memusage(size_t dictionary_size);
 
 
// Inline functions //
 
static inline uint8_t
dict_get(const lzma_dict *const dict, const uint32_t distance)
{
    return dict->buf[dict->pos - distance - 1
            + (distance < dict->pos
                ? 0 : dict->size - LZ_DICT_REPEAT_MAX)];
}
 
 
static inline uint8_t
dict_get0(const lzma_dict *const dict)
{
    return dict->buf[dict->pos - 1];
}
 
 
static inline bool
dict_is_empty(const lzma_dict *const dict)
{
    return dict->full == 0;
}
 
 
static inline bool
dict_is_distance_valid(const lzma_dict *const dict, const size_t distance)
{
    return dict->full > distance;
}
 
 
static inline bool
dict_repeat(lzma_dict *dict, uint32_t distance, uint32_t *len)
{
    // Don't write past the end of the dictionary.
    const size_t dict_avail = dict->limit - dict->pos;
    uint32_t left = my_min(dict_avail, *len);
    *len -= left;
 
    size_t back = dict->pos - distance - 1;
    if (distance >= dict->pos)
        back += dict->size - LZ_DICT_REPEAT_MAX;
 
    // Repeat a block of data from the history. Because memcpy() is faster
    // than copying byte by byte in a loop, the copying process gets split
    // into two cases.
    if (distance < left) {
        // Source and target areas overlap, thus we can't use
        // memcpy() nor even memmove() safely.
        do {
            dict->buf[dict->pos++] = dict->buf[back++];
        } while (--left > 0);
    } else {
        memcpy(dict->buf + dict->pos, dict->buf + back, left);
        dict->pos += left;
    }
 
    // Update how full the dictionary is.
    if (!dict->has_wrapped)
        dict->full = dict->pos - 2 * LZ_DICT_REPEAT_MAX;
 
    return *len != 0;
}
 
 
static inline void
dict_put(lzma_dict *dict, uint8_t byte)
{
    dict->buf[dict->pos++] = byte;
 
    if (!dict->has_wrapped)
        dict->full = dict->pos - 2 * LZ_DICT_REPEAT_MAX;
}
 
 
static inline bool
dict_put_safe(lzma_dict *dict, uint8_t byte)
{
    if (unlikely(dict->pos == dict->limit))
        return true;
 
    dict_put(dict, byte);
    return false;
}
 
 
static inline void
dict_write(lzma_dict *restrict dict, const uint8_t *restrict in,
        size_t *restrict in_pos, size_t in_size,
        size_t *restrict left)
{
    // NOTE: If we are being given more data than the size of the
    // dictionary, it could be possible to optimize the LZ decoder
    // so that not everything needs to go through the dictionary.
    // This shouldn't be very common thing in practice though, and
    // the slowdown of one extra memcpy() isn't bad compared to how
    // much time it would have taken if the data were compressed.
 
    if (in_size - *in_pos > *left)
        in_size = *in_pos + *left;
 
    *left -= lzma_bufcpy(in, in_pos, in_size,
            dict->buf, &dict->pos, dict->limit);
 
    if (!dict->has_wrapped)
        dict->full = dict->pos - 2 * LZ_DICT_REPEAT_MAX;
 
    return;
}
 
 
static inline void
dict_reset(lzma_dict *dict)
{
    dict->need_reset = true;
    return;
}
 
#endif