common.c File Reference

Common functions needed in many places in liblzma. More...

#include "common.h"

Go to the source code of this file.

Functions
	LZMA_API (uint32_t)
	LZMA_API (const char *)
	Run-time version as a string. More...
void *	lzma_attribute ((__malloc__))
void	lzma_free (void *ptr, const lzma_allocator *allocator)
	Frees memory. More...
size_t	lzma_bufcpy (const uint8_t *restrict in, size_t *restrict in_pos, size_t in_size, uint8_t *restrict out, size_t *restrict out_pos, size_t out_size)
lzma_ret	lzma_next_filter_init (lzma_next_coder *next, const lzma_allocator *allocator, const lzma_filter_info *filters)
lzma_ret	lzma_next_filter_update (lzma_next_coder *next, const lzma_allocator *allocator, const lzma_filter *reversed_filters)
void	lzma_next_end (lzma_next_coder *next, const lzma_allocator *allocator)
lzma_ret	lzma_strm_init (lzma_stream *strm)
	LZMA_API (lzma_ret)
	LZMA_API (void)
	LZMA_API (lzma_check)
	LZMA_API (uint64_t)
	Calculate approximate memory usage of easy encoder. More...

Detailed Description

Common functions needed in many places in liblzma.

Definition in file common.c.

Function Documentation

LZMA_API() [1/6]

LZMA_API

(

const char *

)

const

Run-time version as a string.

This function may be useful if you want to display which version of liblzma your application is currently using.

Definition at line 27 of file common.c.

{
    return LZMA_VERSION_STRING;
}

References LZMA_VERSION_STRING.

LZMA_API() [2/6]

LZMA_API

(

lzma_check

)

Definition at line 385 of file common.c.

{
    // Return LZMA_CHECK_NONE if we cannot know the check type.
    // It's a bug in the application if this happens.
    if (strm->internal->next.get_check == NULL)
        return LZMA_CHECK_NONE;
 
    return strm->internal->next.get_check(strm->internal->next.coder);
}

References lzma_next_coder_s::coder, lzma_next_coder_s::get_check, lzma_stream::internal, LZMA_CHECK_NONE, lzma_internal_s::next, NULL, and strm.

LZMA_API() [3/6]

LZMA_API

(

lzma_ret

)

Definition at line 196 of file common.c.

{
    // Sanity checks
    if ((strm->next_in == NULL && strm->avail_in != 0)
            || (strm->next_out == NULL && strm->avail_out != 0)
            || strm->internal == NULL
            || strm->internal->next.code == NULL
            || (unsigned int)(action) > LZMA_ACTION_MAX
            || !strm->internal->supported_actions[action])
        return LZMA_PROG_ERROR;
 
    // Check if unsupported members have been set to non-zero or non-NULL,
    // which would indicate that some new feature is wanted.
    if (strm->reserved_ptr1 != NULL
            || strm->reserved_ptr2 != NULL
            || strm->reserved_ptr3 != NULL
            || strm->reserved_ptr4 != NULL
            || strm->reserved_int1 != 0
            || strm->reserved_int2 != 0
            || strm->reserved_int3 != 0
            || strm->reserved_int4 != 0
            || strm->reserved_enum1 != LZMA_RESERVED_ENUM
            || strm->reserved_enum2 != LZMA_RESERVED_ENUM)
        return LZMA_OPTIONS_ERROR;
 
    switch (strm->internal->sequence) {
    case ISEQ_RUN:
        switch (action) {
        case LZMA_RUN:
            break;
 
        case LZMA_SYNC_FLUSH:
            strm->internal->sequence = ISEQ_SYNC_FLUSH;
            break;
 
        case LZMA_FULL_FLUSH:
            strm->internal->sequence = ISEQ_FULL_FLUSH;
            break;
 
        case LZMA_FINISH:
            strm->internal->sequence = ISEQ_FINISH;
            break;
 
        case LZMA_FULL_BARRIER:
            strm->internal->sequence = ISEQ_FULL_BARRIER;
            break;
        }
 
        break;
 
    case ISEQ_SYNC_FLUSH:
        // The same action must be used until we return
        // LZMA_STREAM_END, and the amount of input must not change.
        if (action != LZMA_SYNC_FLUSH
                || strm->internal->avail_in != strm->avail_in)
            return LZMA_PROG_ERROR;
 
        break;
 
    case ISEQ_FULL_FLUSH:
        if (action != LZMA_FULL_FLUSH
                || strm->internal->avail_in != strm->avail_in)
            return LZMA_PROG_ERROR;
 
        break;
 
    case ISEQ_FINISH:
        if (action != LZMA_FINISH
                || strm->internal->avail_in != strm->avail_in)
            return LZMA_PROG_ERROR;
 
        break;
 
    case ISEQ_FULL_BARRIER:
        if (action != LZMA_FULL_BARRIER
                || strm->internal->avail_in != strm->avail_in)
            return LZMA_PROG_ERROR;
 
        break;
 
    case ISEQ_END:
        return LZMA_STREAM_END;
 
    case ISEQ_ERROR:
    default:
        return LZMA_PROG_ERROR;
    }
 
    size_t in_pos = 0;
    size_t out_pos = 0;
    lzma_ret ret = strm->internal->next.code(
            strm->internal->next.coder, strm->allocator,
            strm->next_in, &in_pos, strm->avail_in,
            strm->next_out, &out_pos, strm->avail_out, action);
 
    strm->next_in += in_pos;
    strm->avail_in -= in_pos;
    strm->total_in += in_pos;
 
    strm->next_out += out_pos;
    strm->avail_out -= out_pos;
    strm->total_out += out_pos;
 
    strm->internal->avail_in = strm->avail_in;
 
    // Cast is needed to silence a warning about LZMA_TIMED_OUT, which
    // isn't part of lzma_ret enumeration.
    switch ((unsigned int)(ret)) {
    case LZMA_OK:
        // Don't return LZMA_BUF_ERROR when it happens the first time.
        // This is to avoid returning LZMA_BUF_ERROR when avail_out
        // was zero but still there was no more data left to written
        // to next_out.
        if (out_pos == 0 && in_pos == 0) {
            if (strm->internal->allow_buf_error)
                ret = LZMA_BUF_ERROR;
            else
                strm->internal->allow_buf_error = true;
        } else {
            strm->internal->allow_buf_error = false;
        }
        break;
 
    case LZMA_TIMED_OUT:
        strm->internal->allow_buf_error = false;
        ret = LZMA_OK;
        break;
 
    case LZMA_STREAM_END:
        if (strm->internal->sequence == ISEQ_SYNC_FLUSH
                || strm->internal->sequence == ISEQ_FULL_FLUSH
                || strm->internal->sequence
                    == ISEQ_FULL_BARRIER)
            strm->internal->sequence = ISEQ_RUN;
        else
            strm->internal->sequence = ISEQ_END;
 
    // Fall through
 
    case LZMA_NO_CHECK:
    case LZMA_UNSUPPORTED_CHECK:
    case LZMA_GET_CHECK:
    case LZMA_MEMLIMIT_ERROR:
        // Something else than LZMA_OK, but not a fatal error,
        // that is, coding may be continued (except if ISEQ_END).
        strm->internal->allow_buf_error = false;
        break;
 
    default:
        // All the other errors are fatal; coding cannot be continued.
        assert(ret != LZMA_BUF_ERROR);
        strm->internal->sequence = ISEQ_ERROR;
        break;
    }
 
    return ret;
}

References test-lz4-speed::action, lzma_stream::allocator, lzma_internal_s::allow_buf_error, assert(), lzma_stream::avail_in, lzma_internal_s::avail_in, lzma_stream::avail_out, lzma_next_coder_s::code, lzma_next_coder_s::coder, in_pos, lzma_stream::internal, LZMA_ACTION_MAX, LZMA_BUF_ERROR, LZMA_FINISH, LZMA_FULL_BARRIER, LZMA_FULL_FLUSH, LZMA_GET_CHECK, LZMA_MEMLIMIT_ERROR, LZMA_NO_CHECK, LZMA_OK, LZMA_OPTIONS_ERROR, LZMA_PROG_ERROR, LZMA_RESERVED_ENUM, LZMA_RUN, LZMA_STREAM_END, LZMA_SYNC_FLUSH, LZMA_TIMED_OUT, LZMA_UNSUPPORTED_CHECK, lzma_internal_s::next, lzma_stream::next_in, lzma_stream::next_out, NULL, out_pos, lzma_stream::reserved_enum1, lzma_stream::reserved_enum2, lzma_stream::reserved_int1, lzma_stream::reserved_int2, lzma_stream::reserved_int3, lzma_stream::reserved_int4, lzma_stream::reserved_ptr1, lzma_stream::reserved_ptr2, lzma_stream::reserved_ptr3, lzma_stream::reserved_ptr4, lzma_internal_s::sequence, strm, lzma_internal_s::supported_actions, lzma_stream::total_in, and lzma_stream::total_out.

LZMA_API() [4/6]

LZMA_API

(

uint32_t

)

Definition at line 20 of file common.c.

{
    return LZMA_VERSION;
}

References LZMA_VERSION.

LZMA_API() [5/6]

LZMA_API

(

uint64_t

)

Calculate approximate memory usage of easy encoder.

Get the total amount of physical memory (RAM) in bytes.

Calculate approximate memory usage of multithreaded .xz encoder.

Calculate approximate decoder memory usage of a preset.

This function is a wrapper for lzma_raw_encoder_memusage().

Parameters

preset

Compression preset (level and possible flags)

Returns

Number of bytes of memory required for the given preset when encoding. If an error occurs, for example due to unsupported preset, UINT64_MAX is returned.

This function is a wrapper for lzma_raw_decoder_memusage().

Parameters

preset

Compression preset (level and possible flags)

Returns

Number of bytes of memory required to decompress a file that was compressed using the given preset. If an error occurs, for example due to unsupported preset, UINT64_MAX is returned.

Since doing the encoding in threaded mode doesn't affect the memory requirements of single-threaded decompressor, you can use lzma_easy_decoder_memusage(options->preset) or lzma_raw_decoder_memusage(options->filters) to calculate the decompressor memory requirements.

Parameters

options

Compression options

Returns

Number of bytes of memory required for encoding with the given options. If an error occurs, for example due to unsupported preset or filter chain, UINT64_MAX is returned.

Calculate approximate memory usage of easy encoder.

Get the uncompressed size of the file.

Get the total size of the file.

Get the total size of the Blocks.

Get the total size of the Stream.

Get the size of the Index field as bytes.

Get the number of Blocks.

Get the number of Streams.

Calculate the memory usage of an existing lzma_index.

On disk, the size of the Index field depends on both the number of Records stored and how big values the Records store (due to variable-length integer encoding). When the Index is kept in lzma_index structure, the memory usage depends only on the number of Records/Blocks stored in the Index(es), and in case of concatenated lzma_indexes, the number of Streams. The size in RAM is almost always significantly bigger than in the encoded form on disk.

This function calculates an approximate amount of memory needed hold the given number of Streams and Blocks in lzma_index structure. This value may vary between CPU architectures and also between liblzma versions if the internal implementation is modified.

This is a shorthand for lzma_index_memusage(lzma_index_stream_count(i), lzma_index_block_count(i)).

This returns the total number of Blocks in lzma_index. To get number of Blocks in individual Streams, use lzma_index_iter.

This is needed to verify the Backward Size field in the Stream Footer.

If multiple lzma_indexes have been combined, this works as if the Blocks were in a single Stream. This is useful if you are going to combine Blocks from multiple Streams into a single new Stream.

This doesn't include the Stream Header, Stream Footer, Stream Padding, or Index fields.

When no lzma_indexes have been combined with lzma_index_cat() and there is no Stream Padding, this function is identical to lzma_index_stream_size(). If multiple lzma_indexes have been combined, this includes also the headers of each separate Stream and the possible Stream Padding fields.

Definition at line 397 of file common.c.

{
    uint64_t memusage;
    uint64_t old_memlimit;
 
    if (strm == NULL || strm->internal == NULL
            || strm->internal->next.memconfig == NULL
            || strm->internal->next.memconfig(
                strm->internal->next.coder,
                &memusage, &old_memlimit, 0) != LZMA_OK)
        return 0;
 
    return memusage;
}

References lzma_next_coder_s::coder, lzma_stream::internal, LZMA_OK, lzma_next_coder_s::memconfig, lzma_internal_s::next, NULL, and strm.

LZMA_API() [6/6]

LZMA_API

(

void

)

Definition at line 356 of file common.c.

{
    if (strm != NULL && strm->internal != NULL) {
        lzma_next_end(&strm->internal->next, strm->allocator);
        lzma_free(strm->internal, strm->allocator);
        strm->internal = NULL;
    }
 
    return;
}

References lzma_stream::allocator, lzma_stream::internal, lzma_free(), lzma_next_end(), lzma_internal_s::next, NULL, and strm.

lzma_attribute()

void * lzma_attribute

(

(__malloc__)

)

Definition at line 38 of file common.c.

{
    // Some malloc() variants return NULL if called with size == 0.
    if (size == 0)
        size = 1;
 
    void *ptr;
 
    if (allocator != NULL && allocator->alloc != NULL)
        ptr = allocator->alloc(allocator->opaque, 1, size);
    else
        ptr = malloc(size);
 
    return ptr;
}

References lzma_allocator::alloc(), allocator, malloc(), NULL, and lzma_allocator::opaque.

lzma_bufcpy()

size_t lzma_bufcpy	(	const uint8_t *restrict	in,
		size_t *restrict	in_pos,
		size_t	in_size,
		uint8_t *restrict	out,
		size_t *restrict	out_pos,
		size_t	out_size
	)

Copy as much data as possible from in[] to out[] and update *in_pos and *out_pos accordingly. Returns the number of bytes copied.

Definition at line 94 of file common.c.

{
    const size_t in_avail = in_size - *in_pos;
    const size_t out_avail = out_size - *out_pos;
    const size_t copy_size = my_min(in_avail, out_avail);
 
    // Call memcpy() only if there is something to copy. If there is
    // nothing to copy, in or out might be NULL and then the memcpy()
    // call would trigger undefined behavior.
    if (copy_size > 0)
        memcpy(out + *out_pos, in + *in_pos, copy_size);
 
    *in_pos += copy_size;
    *out_pos += copy_size;
 
    return copy_size;
}

References in, in_pos, in_size, memcpy(), my_min, out, and out_pos.

Referenced by alone_encode(), block_decode(), block_encode(), copy_or_code(), dict_write(), fill_window(), lzma2_encode(), lzma_outq_read(), simple_code(), stream_decode(), stream_encode(), stream_encode_in(), and stream_encode_mt().

lzma_free()

void lzma_free	(	void *	ptr,
		const lzma_allocator *	allocator
	)

Frees memory.

Definition at line 78 of file common.c.

{
    if (allocator != NULL && allocator->free != NULL)
        allocator->free(allocator->opaque, ptr);
    else
        free(ptr);
 
    return;
}

References allocator, free(), NULL, and lzma_allocator::opaque.

Referenced by alone_decoder_end(), alone_encoder_end(), auto_decoder_end(), block_decoder_end(), block_encoder_end(), delta_coder_end(), free_properties(), index_decoder_end(), index_encoder_end(), index_stream_end(), initialize_new_thread(), lz_decoder_end(), lz_encoder_end(), lz_encoder_init(), lz_encoder_prepare(), lzma2_decoder_end(), lzma2_encoder_end(), LZMA_API(), lzma_lz_decoder_init(), lzma_lzma_props_decode(), lzma_next_end(), lzma_outq_end(), lzma_simple_props_decode(), simple_coder_end(), stream_decode(), stream_decoder_end(), stream_encoder_end(), stream_encoder_mt_end(), stream_encoder_mt_init(), stream_encoder_update(), threads_end(), and worker_start().

lzma_next_end()

void lzma_next_end	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator
	)

Frees the memory allocated for next->coder either using next->end or, if next->end is NULL, using lzma_free.

Definition at line 145 of file common.c.

{
    if (next->init != (uintptr_t)(NULL)) {
        // To avoid tiny end functions that simply call
        // lzma_free(coder, allocator), we allow leaving next->end
        // NULL and call lzma_free() here.
        if (next->end != NULL)
            next->end(next->coder, allocator);
        else
            lzma_free(next->coder, allocator);
 
        // Reset the variables so the we don't accidentally think
        // that it is an already initialized coder.
        *next = LZMA_NEXT_CODER_INIT;
    }
 
    return;
}

References allocator, lzma_next_coder_s::coder, lzma_next_coder_s::end, lzma_next_coder_s::init, lzma_free(), LZMA_NEXT_CODER_INIT, and NULL.

Referenced by alone_decoder_end(), alone_encoder_end(), auto_decoder_end(), block_decoder_end(), block_encode_normal(), block_encoder_end(), delta_coder_end(), lz_decoder_end(), lz_encoder_end(), LZMA_API(), lzma_raw_coder_init(), simple_coder_end(), stream_decoder_end(), stream_encoder_end(), stream_encoder_mt_end(), and worker_start().

lzma_next_filter_init()

lzma_ret lzma_next_filter_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter_info *	filters
	)

Initializes the next filter in the chain, if any. This takes care of freeing the memory of previously initialized filter if it is different than the filter being initialized now. This way the actual filter initialization functions don't need to use lzma_next_coder_init macro.

Definition at line 116 of file common.c.

{
    lzma_next_coder_init(filters[0].init, next, allocator);
    next->id = filters[0].id;
    return filters[0].init == NULL
            ? LZMA_OK : filters[0].init(next, allocator, filters);
}

References allocator, filters, lzma_filter::id, lzma_next_coder_s::id, init, lzma_next_coder_init, LZMA_OK, and NULL.

Referenced by alone_decode(), alone_encoder_init(), lzma_delta_coder_init(), lzma_lz_decoder_init(), lzma_lz_encoder_init(), lzma_raw_coder_init(), and lzma_simple_coder_init().

lzma_next_filter_update()

lzma_ret lzma_next_filter_update	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter *	reversed_filters
	)

Update the next filter in the chain, if any. This checks that the application is not trying to change the Filter IDs.

Definition at line 127 of file common.c.

{
    // Check that the application isn't trying to change the Filter ID.
    // End of filters is indicated with LZMA_VLI_UNKNOWN in both
    // reversed_filters[0].id and next->id.
    if (reversed_filters[0].id != next->id)
        return LZMA_PROG_ERROR;
 
    if (reversed_filters[0].id == LZMA_VLI_UNKNOWN)
        return LZMA_OK;
 
    assert(next->update != NULL);
    return next->update(next->coder, allocator, NULL, reversed_filters);
}

References allocator, assert(), lzma_next_coder_s::coder, lzma_next_coder_s::id, LZMA_OK, LZMA_PROG_ERROR, LZMA_VLI_UNKNOWN, NULL, and lzma_next_coder_s::update.

Referenced by block_encoder_update(), delta_encoder_update(), lz_encoder_update(), and simple_coder_update().

lzma_strm_init()

lzma_ret lzma_strm_init

(

lzma_stream *

strm

)

Allocates strm->internal if it is NULL, and initializes *strm and strm->internal. This function is only called via lzma_next_strm_init macro.

Definition at line 170 of file common.c.

{
    if (strm == NULL)
        return LZMA_PROG_ERROR;
 
    if (strm->internal == NULL) {
        strm->internal = lzma_alloc(sizeof(lzma_internal),
                strm->allocator);
        if (strm->internal == NULL)
            return LZMA_MEM_ERROR;
 
        strm->internal->next = LZMA_NEXT_CODER_INIT;
    }
 
    memzero(strm->internal->supported_actions,
            sizeof(strm->internal->supported_actions));
    strm->internal->sequence = ISEQ_RUN;
    strm->internal->allow_buf_error = false;
 
    strm->total_in = 0;
    strm->total_out = 0;
 
    return LZMA_OK;
}

References lzma_stream::allocator, lzma_internal_s::allow_buf_error, lzma_stream::internal, lzma_alloc(), LZMA_MEM_ERROR, LZMA_NEXT_CODER_INIT, LZMA_OK, LZMA_PROG_ERROR, memzero, lzma_internal_s::next, NULL, lzma_internal_s::sequence, strm, lzma_internal_s::supported_actions, lzma_stream::total_in, and lzma_stream::total_out.