coder.h File Reference

Compresses or uncompresses a file. More...

Go to the source code of this file.

Enumerations
enum	operation_mode { MODE_COMPRESS , MODE_DECOMPRESS , MODE_TEST , MODE_LIST }
enum	format_type { FORMAT_AUTO , FORMAT_XZ , FORMAT_LZMA , FORMAT_RAW }

Functions
void	coder_set_check (lzma_check check)
	Set the integrity check type used when compressing. More...
void	coder_set_preset (uint32_t new_preset)
	Set preset number. More...
void	coder_set_extreme (void)
	Enable extreme mode. More...
void	coder_add_filter (lzma_vli id, void *options)
	Add a filter to the custom filter chain. More...
void	coder_set_compression_settings (void)
void	coder_run (const char *filename)
	Compress or decompress the given file. More...
void	coder_free (void)
	Free the memory allocated for the coder and kill the worker threads. More...

Variables
enum operation_mode	opt_mode
enum format_type	opt_format
bool	opt_auto_adjust
bool	opt_single_stream
	If true, stop after decoding the first stream. More...
uint64_t	opt_block_size
uint64_t *	opt_block_list

Detailed Description

Compresses or uncompresses a file.

Definition in file coder.h.

Enumeration Type Documentation

format_type

enum format_type

Enumerator
FORMAT_AUTO
FORMAT_XZ
FORMAT_LZMA
FORMAT_RAW

Definition at line 22 of file coder.h.

                 {
    FORMAT_AUTO,
    FORMAT_XZ,
    FORMAT_LZMA,
    // HEADER_GZIP,
    FORMAT_RAW,
};

operation_mode

enum operation_mode

Enumerator
MODE_COMPRESS
MODE_DECOMPRESS
MODE_TEST
MODE_LIST

Definition at line 13 of file coder.h.

                    {
    MODE_COMPRESS,
    MODE_DECOMPRESS,
    MODE_TEST,
    MODE_LIST,
};

Function Documentation

coder_add_filter()

void coder_add_filter	(	lzma_vli	id,
		void *	options
	)

Add a filter to the custom filter chain.

Definition at line 107 of file coder.c.

{
    if (filters_count == LZMA_FILTERS_MAX)
        message_fatal(_("Maximum number of filters is four"));
 
    filters[filters_count].id = id;
    filters[filters_count].options = options;
    ++filters_count;
 
    // Setting a custom filter chain makes us forget the preset options.
    // This makes a difference if one specifies e.g. "xz -9 --lzma2 -e"
    // where the custom filter chain resets the preset level back to
    // the default 6, making the example equivalent to "xz -6e".
    preset_number = LZMA_PRESET_DEFAULT;
 
    return;
}

References _, filters, filters_count, id, lzma_filter::id, LZMA_FILTERS_MAX, LZMA_PRESET_DEFAULT, message_fatal(), options, lzma_filter::options, and preset_number.

Referenced by parse_real().

coder_free()

void coder_free

(

void

)

Free the memory allocated for the coder and kill the worker threads.

Definition at line 939 of file coder.c.

{
    lzma_end(&strm);
    return;
}

References strm.

Referenced by main().

coder_run()

void coder_run

(

const char *

filename

)

Compress or decompress the given file.

Definition at line 869 of file coder.c.

{
    // Set and possibly print the filename for the progress message.
    message_filename(filename);
 
    // Try to open the input file.
    file_pair *pair = io_open_src(filename);
    if (pair == NULL)
        return;
 
    // Assume that something goes wrong.
    bool success = false;
 
    if (opt_mode == MODE_COMPRESS) {
        strm.next_in = NULL;
        strm.avail_in = 0;
    } else {
        // Read the first chunk of input data. This is needed
        // to detect the input file type.
        strm.next_in = in_buf.u8;
        strm.avail_in = io_read(pair, &in_buf, IO_BUFFER_SIZE);
    }
 
    if (strm.avail_in != SIZE_MAX) {
        // Initialize the coder. This will detect the file format
        // and, in decompression or testing mode, check the memory
        // usage of the first Block too. This way we don't try to
        // open the destination file if we see that coding wouldn't
        // work at all anyway. This also avoids deleting the old
        // "target" file if --force was used.
        const enum coder_init_ret init_ret = coder_init(pair);
 
        if (init_ret != CODER_INIT_ERROR && !user_abort) {
            // Don't open the destination file when --test
            // is used.
            if (opt_mode == MODE_TEST || !io_open_dest(pair)) {
                // Remember the current time. It is needed
                // for progress indicator.
                mytime_set_start_time();
 
                // Initialize the progress indicator.
                const bool is_passthru = init_ret
                        == CODER_INIT_PASSTHRU;
                const uint64_t in_size
                    = pair->src_st.st_size <= 0
                    ? 0 : (uint64_t)(pair->src_st.st_size);
                message_progress_start(&strm,
                        is_passthru, in_size);
 
                // Do the actual coding or passthru.
                if (is_passthru)
                    success = coder_passthru(pair);
                else
                    success = coder_normal(pair);
 
                message_progress_end(success);
            }
        }
    }
 
    // Close the file pair. It needs to know if coding was successful to
    // know if the source or target file should be unlinked.
    io_close(pair, success);
 
    return;
}

References lzma_stream::avail_in, coder_init(), CODER_INIT_ERROR, CODER_INIT_PASSTHRU, coder_normal(), coder_passthru(), in_buf, in_size, IO_BUFFER_SIZE, io_close(), io_open_dest(), io_open_src(), io_read(), message_filename(), message_progress_end(), message_progress_start(), MODE_COMPRESS, MODE_TEST, mytime_set_start_time(), lzma_stream::next_in, NULL, opt_mode, SIZE_MAX, file_pair::src_st, strm, io_buf::u8, and user_abort.

Referenced by main().

coder_set_check()

void coder_set_check

(

lzma_check

check

)

Set the integrity check type used when compressing.

Definition at line 64 of file coder.c.

{
    check = new_check;
    check_default = false;
    return;
}

References check, and check_default.

Referenced by parse_real().

coder_set_compression_settings()

void coder_set_compression_settings

(

void

)

Definition at line 137 of file coder.c.

{
    // The default check type is CRC64, but fallback to CRC32
    // if CRC64 isn't supported by the copy of liblzma we are
    // using. CRC32 is always supported.
    if (check_default) {
        check = LZMA_CHECK_CRC64;
        if (!lzma_check_is_supported(check))
            check = LZMA_CHECK_CRC32;
    }
 
    // Options for LZMA1 or LZMA2 in case we are using a preset.
    static lzma_options_lzma opt_lzma;
 
    if (filters_count == 0) {
        // We are using a preset. This is not a good idea in raw mode
        // except when playing around with things. Different versions
        // of this software may use different options in presets, and
        // thus make uncompressing the raw data difficult.
        if (opt_format == FORMAT_RAW) {
            // The message is shown only if warnings are allowed
            // but the exit status isn't changed.
            message(V_WARNING, _("Using a preset in raw mode "
                    "is discouraged."));
            message(V_WARNING, _("The exact options of the "
                    "presets may vary between software "
                    "versions."));
        }
 
        // Get the preset for LZMA1 or LZMA2.
        if (lzma_lzma_preset(&opt_lzma, preset_number))
            message_bug();
 
        // Use LZMA2 except with --format=lzma we use LZMA1.
        filters[0].id = opt_format == FORMAT_LZMA
                ? LZMA_FILTER_LZMA1 : LZMA_FILTER_LZMA2;
        filters[0].options = &opt_lzma;
        filters_count = 1;
    }
 
    // Terminate the filter options array.
    filters[filters_count].id = LZMA_VLI_UNKNOWN;
 
    // If we are using the .lzma format, allow exactly one filter
    // which has to be LZMA1.
    if (opt_format == FORMAT_LZMA && (filters_count != 1
            || filters[0].id != LZMA_FILTER_LZMA1))
        message_fatal(_("The .lzma format supports only "
                "the LZMA1 filter"));
 
    // If we are using the .xz format, make sure that there is no LZMA1
    // filter to prevent LZMA_PROG_ERROR.
    if (opt_format == FORMAT_XZ)
        for (size_t i = 0; i < filters_count; ++i)
            if (filters[i].id == LZMA_FILTER_LZMA1)
                message_fatal(_("LZMA1 cannot be used "
                        "with the .xz format"));
 
    // Print the selected filter chain.
    message_filters_show(V_DEBUG, filters);
 
    // The --flush-timeout option requires LZMA_SYNC_FLUSH support
    // from the filter chain. Currently threaded encoder doesn't support
    // LZMA_SYNC_FLUSH so single-threaded mode must be used.
    if (opt_mode == MODE_COMPRESS && opt_flush_timeout != 0) {
        for (size_t i = 0; i < filters_count; ++i) {
            switch (filters[i].id) {
            case LZMA_FILTER_LZMA2:
            case LZMA_FILTER_DELTA:
                break;
 
            default:
                message_fatal(_("The filter chain is "
                    "incompatible with --flush-timeout"));
            }
        }
 
        if (hardware_threads_get() > 1) {
            message(V_WARNING, _("Switching to single-threaded "
                    "mode due to --flush-timeout"));
            hardware_threads_set(1);
        }
    }
 
    // Get the memory usage. Note that if --format=raw was used,
    // we can be decompressing.
    const uint64_t memory_limit = hardware_memlimit_get(opt_mode);
    uint64_t memory_usage = UINT64_MAX;
    if (opt_mode == MODE_COMPRESS) {
#ifdef HAVE_ENCODERS
#   ifdef MYTHREAD_ENABLED
        if (opt_format == FORMAT_XZ && hardware_threads_get() > 1) {
            mt_options.threads = hardware_threads_get();
            mt_options.block_size = opt_block_size;
            mt_options.check = check;
            memory_usage = lzma_stream_encoder_mt_memusage(
                    &mt_options);
            if (memory_usage != UINT64_MAX)
                message(V_DEBUG, _("Using up to %" PRIu32
                        " threads."),
                        mt_options.threads);
        } else
#   endif
        {
            memory_usage = lzma_raw_encoder_memusage(filters);
        }
#endif
    } else {
#ifdef HAVE_DECODERS
        memory_usage = lzma_raw_decoder_memusage(filters);
#endif
    }
 
    if (memory_usage == UINT64_MAX)
        message_fatal(_("Unsupported filter chain or filter options"));
 
    // Print memory usage info before possible dictionary
    // size auto-adjusting.
    //
    // NOTE: If only encoder support was built, we cannot show the
    // what the decoder memory usage will be.
    message_mem_needed(V_DEBUG, memory_usage);
#ifdef HAVE_DECODERS
    if (opt_mode == MODE_COMPRESS) {
        const uint64_t decmem = lzma_raw_decoder_memusage(filters);
        if (decmem != UINT64_MAX)
            message(V_DEBUG, _("Decompression will need "
                    "%s MiB of memory."), uint64_to_str(
                        round_up_to_mib(decmem), 0));
    }
#endif
 
    if (memory_usage <= memory_limit)
        return;
 
    // If --no-adjust was used or we didn't find LZMA1 or
    // LZMA2 as the last filter, give an error immediately.
    // --format=raw implies --no-adjust.
    if (!opt_auto_adjust || opt_format == FORMAT_RAW)
        memlimit_too_small(memory_usage);
 
    assert(opt_mode == MODE_COMPRESS);
 
#ifdef HAVE_ENCODERS
#   ifdef MYTHREAD_ENABLED
    if (opt_format == FORMAT_XZ && mt_options.threads > 1) {
        // Try to reduce the number of threads before
        // adjusting the compression settings down.
        do {
            // FIXME? The real single-threaded mode has
            // lower memory usage, but it's not comparable
            // because it doesn't write the size info
            // into Block Headers.
            if (--mt_options.threads == 0)
                memlimit_too_small(memory_usage);
 
            memory_usage = lzma_stream_encoder_mt_memusage(
                    &mt_options);
            if (memory_usage == UINT64_MAX)
                message_bug();
 
        } while (memory_usage > memory_limit);
 
        message(V_WARNING, _("Adjusted the number of threads "
            "from %s to %s to not exceed "
            "the memory usage limit of %s MiB"),
            uint64_to_str(hardware_threads_get(), 0),
            uint64_to_str(mt_options.threads, 1),
            uint64_to_str(round_up_to_mib(
                memory_limit), 2));
    }
#   endif
 
    if (memory_usage <= memory_limit)
        return;
 
    // Look for the last filter if it is LZMA2 or LZMA1, so we can make
    // it use less RAM. With other filters we don't know what to do.
    size_t i = 0;
    while (filters[i].id != LZMA_FILTER_LZMA2
            && filters[i].id != LZMA_FILTER_LZMA1) {
        if (filters[i].id == LZMA_VLI_UNKNOWN)
            memlimit_too_small(memory_usage);
 
        ++i;
    }
 
    // Decrease the dictionary size until we meet the memory
    // usage limit. First round down to full mebibytes.
    lzma_options_lzma *opt = filters[i].options;
    const uint32_t orig_dict_size = opt->dict_size;
    opt->dict_size &= ~((UINT32_C(1) << 20) - 1);
    while (true) {
        // If it is below 1 MiB, auto-adjusting failed. We could be
        // more sophisticated and scale it down even more, but let's
        // see if many complain about this version.
        //
        // FIXME: Displays the scaled memory usage instead
        // of the original.
        if (opt->dict_size < (UINT32_C(1) << 20))
            memlimit_too_small(memory_usage);
 
        memory_usage = lzma_raw_encoder_memusage(filters);
        if (memory_usage == UINT64_MAX)
            message_bug();
 
        // Accept it if it is low enough.
        if (memory_usage <= memory_limit)
            break;
 
        // Otherwise 1 MiB down and try again. I hope this
        // isn't too slow method for cases where the original
        // dict_size is very big.
        opt->dict_size -= UINT32_C(1) << 20;
    }
 
    // Tell the user that we decreased the dictionary size.
    message(V_WARNING, _("Adjusted LZMA%c dictionary size "
            "from %s MiB to %s MiB to not exceed "
            "the memory usage limit of %s MiB"),
            filters[i].id == LZMA_FILTER_LZMA2
                ? '2' : '1',
            uint64_to_str(orig_dict_size >> 20, 0),
            uint64_to_str(opt->dict_size >> 20, 1),
            uint64_to_str(round_up_to_mib(memory_limit), 2));
#endif
 
    return;
}

Referenced by args_parse().

coder_set_extreme()

void coder_set_extreme

(

void

)

Enable extreme mode.

Definition at line 98 of file coder.c.

{
    preset_number |= LZMA_PRESET_EXTREME;
    forget_filter_chain();
    return;
}

References forget_filter_chain(), LZMA_PRESET_EXTREME, and preset_number.

Referenced by parse_real().

coder_set_preset()

void coder_set_preset

(

uint32_t

new_preset

)

Set preset number.

Definition at line 88 of file coder.c.

{
    preset_number &= ~LZMA_PRESET_LEVEL_MASK;
    preset_number |= new_preset;
    forget_filter_chain();
    return;
}

References forget_filter_chain(), LZMA_PRESET_LEVEL_MASK, and preset_number.

Referenced by parse_real().

Variable Documentation

opt_auto_adjust

bool opt_auto_adjust

extern

If true, the compression settings are automatically adjusted down if they exceed the memory usage limit.

Definition at line 26 of file coder.c.

Referenced by coder_init(), and parse_real().

opt_block_list

uint64_t* opt_block_list

extern

This is non-NULL if –block-list was used. This contains the Block sizes as an array that is terminated with 0.

Definition at line 29 of file coder.c.

Referenced by args_free(), coder_normal(), parse_block_list(), and split_block().

opt_block_size

uint64_t opt_block_size

extern

If non-zero, start a new .xz Block after every opt_block_size bytes of input. This has an effect only when compressing to the .xz format.

Definition at line 28 of file coder.c.

Referenced by coder_init(), coder_normal(), parse_real(), and split_block().

opt_format

enum format_type opt_format

extern

File format to use when encoding or what format(s) to accept when decoding. This is a global because it's needed also in suffix.c. This is set in args.c.

Definition at line 1 of file coder.c.

Referenced by args_parse(), coder_init(), coder_normal(), compressed_name(), list_file(), parse_real(), and uncompressed_name().

opt_mode

enum operation_mode opt_mode

extern

Operation mode of the command line tool. This is set in args.c and read in several files.

Definition at line 1 of file coder.c.

Referenced by args_parse(), coder_init(), coder_normal(), coder_run(), coder_write_output(), io_open_dest_real(), io_open_src_real(), main(), message_filename(), message_mem_needed(), mytime_get_flush_timeout(), parse_real(), print_filename(), progress_pos(), and suffix_get_dest_name().

opt_single_stream

bool opt_single_stream

extern

If true, stop after decoding the first stream.

Definition at line 27 of file coder.c.

Referenced by coder_normal(), and parse_real().