From a065da8b13f4cfca612b10ee3d6f3b83c336fcdb Mon Sep 17 00:00:00 2001 From: pelya Date: Tue, 11 Nov 2014 22:04:49 +0200 Subject: [PATCH] Updated liblzma --- project/jni/lzma/config.h | 10 +- project/jni/lzma/include/lzma/block.h | 4 + project/jni/lzma/include/lzma/container.h | 12 ++ project/jni/lzma/include/lzma/filter.h | 8 +- project/jni/lzma/include/lzma/lzma.h | 3 + project/jni/lzma/include/lzma/version.h | 2 +- project/jni/lzma/src/common/sysdefs.h | 24 +++- .../jni/lzma/src/common/tuklib_open_stdxxx.c | 4 +- .../jni/lzma/src/liblzma/check/crc32_fast.c | 2 +- .../jni/lzma/src/liblzma/check/crc32_small.c | 61 +++++++++ .../lzma/src/liblzma/check/crc32_tablegen.c | 117 ++++++++++++++++++ .../jni/lzma/src/liblzma/check/crc64_small.c | 53 ++++++++ .../lzma/src/liblzma/check/crc64_tablegen.c | 88 +++++++++++++ project/jni/lzma/src/liblzma/check/sha256.c | 3 +- .../lzma/src/liblzma/common/alone_decoder.c | 24 ++-- .../lzma/src/liblzma/common/alone_decoder.h | 5 +- .../lzma/src/liblzma/common/alone_encoder.c | 4 +- .../lzma/src/liblzma/common/auto_decoder.c | 2 +- .../src/liblzma/common/block_buffer_encoder.c | 18 ++- .../lzma/src/liblzma/common/block_encoder.c | 7 +- project/jni/lzma/src/liblzma/common/common.c | 2 +- project/jni/lzma/src/liblzma/common/common.h | 2 +- .../lzma/src/liblzma/common/filter_common.c | 6 +- project/jni/lzma/src/liblzma/common/index.c | 7 +- .../lzma/src/liblzma/common/index_decoder.c | 9 +- .../lzma/src/liblzma/common/index_encoder.c | 11 +- .../liblzma/common/stream_buffer_encoder.c | 23 ++-- .../lzma/src/liblzma/common/stream_encoder.c | 2 +- .../lzma/src/liblzma/delta/delta_encoder.c | 2 +- project/jni/lzma/src/liblzma/liblzma.pc | 19 --- project/jni/lzma/src/liblzma/lz/lz_decoder.c | 2 +- project/jni/lzma/src/liblzma/lz/lz_encoder.c | 2 +- .../jni/lzma/src/liblzma/lz/lz_encoder_hash.h | 2 +- .../lzma/src/liblzma/lzma/fastpos_tablegen.c | 56 +++++++++ .../jni/lzma/src/liblzma/lzma/lzma2_decoder.c | 8 +- .../jni/lzma/src/liblzma/lzma/lzma2_encoder.c | 2 +- .../src/liblzma/lzma/lzma_encoder_presets.c | 8 +- .../src/liblzma/rangecoder/price_tablegen.c | 87 +++++++++++++ project/jni/lzma/src/liblzma/simple/arm.c | 2 +- .../jni/lzma/src/liblzma/simple/armthumb.c | 2 +- project/jni/lzma/src/liblzma/simple/ia64.c | 2 +- project/jni/lzma/src/liblzma/simple/powerpc.c | 2 +- .../lzma/src/liblzma/simple/simple_coder.c | 7 +- .../lzma/src/liblzma/simple/simple_private.h | 3 +- project/jni/lzma/src/liblzma/simple/sparc.c | 2 +- 45 files changed, 620 insertions(+), 101 deletions(-) create mode 100644 project/jni/lzma/src/liblzma/check/crc32_small.c create mode 100644 project/jni/lzma/src/liblzma/check/crc32_tablegen.c create mode 100644 project/jni/lzma/src/liblzma/check/crc64_small.c create mode 100644 project/jni/lzma/src/liblzma/check/crc64_tablegen.c delete mode 100644 project/jni/lzma/src/liblzma/liblzma.pc create mode 100644 project/jni/lzma/src/liblzma/lzma/fastpos_tablegen.c create mode 100644 project/jni/lzma/src/liblzma/rangecoder/price_tablegen.c diff --git a/project/jni/lzma/config.h b/project/jni/lzma/config.h index 7147107a9..59a8b95b4 100644 --- a/project/jni/lzma/config.h +++ b/project/jni/lzma/config.h @@ -5,7 +5,7 @@ /* #undef AC_APPLE_UNIVERSAL_BUILD */ /* How many MiB of RAM to assume if the real amount cannot be determined. */ -#define ASSUME_RAM 16 +#define ASSUME_RAM 64 /* Define to 1 if translation of program messages to the user's native language is requested. */ @@ -255,7 +255,7 @@ #define PACKAGE_NAME "XZ Utils" /* Define to the full name and version of this package. */ -#define PACKAGE_STRING "XZ Utils 5.0.0" +#define PACKAGE_STRING "XZ Utils 5.0.7" /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "xz" @@ -264,14 +264,18 @@ #define PACKAGE_URL "http://tukaani.org/xz/" /* Define to the version of this package. */ -#define PACKAGE_VERSION "5.0.0" +#define PACKAGE_VERSION "5.0.7" /* Define to necessary symbol if this constant uses a non-standard name on your system. */ /* #undef PTHREAD_CREATE_JOINABLE */ /* The size of `size_t', as computed by sizeof. */ +#ifdef __LP64__ +#define SIZEOF_SIZE_T 8 +#else #define SIZEOF_SIZE_T 4 +#endif /* Define to 1 if you have the ANSI C header files. */ #define STDC_HEADERS 1 diff --git a/project/jni/lzma/include/lzma/block.h b/project/jni/lzma/include/lzma/block.h index 3019bf916..e6710a7bc 100644 --- a/project/jni/lzma/include/lzma/block.h +++ b/project/jni/lzma/include/lzma/block.h @@ -318,6 +318,9 @@ extern LZMA_API(lzma_ret) lzma_block_header_encode( * The size of the Block Header must have already been decoded with * lzma_block_header_size_decode() macro and stored to block->header_size. * + * The integrity check type from Stream Header must have been stored + * to block->check. + * * block->filters must have been allocated, but they don't need to be * initialized (possible existing filter options are not freed). * @@ -483,6 +486,7 @@ extern LZMA_API(size_t) lzma_block_buffer_bound(size_t uncompressed_size) * * \return - LZMA_OK: Encoding was successful. * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_UNSUPPORTED_CHECK * - LZMA_OPTIONS_ERROR * - LZMA_MEM_ERROR * - LZMA_DATA_ERROR diff --git a/project/jni/lzma/include/lzma/container.h b/project/jni/lzma/include/lzma/container.h index 83e70b44f..7a9ffc645 100644 --- a/project/jni/lzma/include/lzma/container.h +++ b/project/jni/lzma/include/lzma/container.h @@ -66,6 +66,10 @@ * This function is a wrapper for lzma_raw_encoder_memusage(). * * \param preset Compression preset (level and possible flags) + * + * \return 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. */ extern LZMA_API(uint64_t) lzma_easy_encoder_memusage(uint32_t preset) lzma_nothrow lzma_attr_pure; @@ -77,6 +81,11 @@ extern LZMA_API(uint64_t) lzma_easy_encoder_memusage(uint32_t preset) * This function is a wrapper for lzma_raw_decoder_memusage(). * * \param preset Compression preset (level and possible flags) + * + * \return 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. */ extern LZMA_API(uint64_t) lzma_easy_decoder_memusage(uint32_t preset) lzma_nothrow lzma_attr_pure; @@ -148,6 +157,7 @@ extern LZMA_API(lzma_ret) lzma_easy_encoder( * * \return - LZMA_OK: Encoding was successful. * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_UNSUPPORTED_CHECK * - LZMA_OPTIONS_ERROR * - LZMA_MEM_ERROR * - LZMA_DATA_ERROR @@ -171,6 +181,7 @@ extern LZMA_API(lzma_ret) lzma_easy_buffer_encode( * * \return - LZMA_OK: Initialization was successful. * - LZMA_MEM_ERROR + * - LZMA_UNSUPPORTED_CHECK * - LZMA_OPTIONS_ERROR * - LZMA_PROG_ERROR */ @@ -250,6 +261,7 @@ extern LZMA_API(size_t) lzma_stream_buffer_bound(size_t uncompressed_size) * * \return - LZMA_OK: Encoding was successful. * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_UNSUPPORTED_CHECK * - LZMA_OPTIONS_ERROR * - LZMA_MEM_ERROR * - LZMA_DATA_ERROR diff --git a/project/jni/lzma/include/lzma/filter.h b/project/jni/lzma/include/lzma/filter.h index efd036f7f..e0bc163ad 100644 --- a/project/jni/lzma/include/lzma/filter.h +++ b/project/jni/lzma/include/lzma/filter.h @@ -131,7 +131,9 @@ extern LZMA_API(lzma_ret) lzma_filters_copy(const lzma_filter *src, * .id == LZMA_VLI_UNKNOWN. * * \return Number of bytes of memory required for the given - * filter chain when encoding. + * filter chain when encoding. If an error occurs, + * for example due to unsupported filter chain, + * UINT64_MAX is returned. */ extern LZMA_API(uint64_t) lzma_raw_encoder_memusage(const lzma_filter *filters) lzma_nothrow lzma_attr_pure; @@ -148,7 +150,9 @@ extern LZMA_API(uint64_t) lzma_raw_encoder_memusage(const lzma_filter *filters) * .id == LZMA_VLI_UNKNOWN. * * \return Number of bytes of memory required for the given - * filter chain when decoding. + * filter chain when decoding. If an error occurs, + * for example due to unsupported filter chain, + * UINT64_MAX is returned. */ extern LZMA_API(uint64_t) lzma_raw_decoder_memusage(const lzma_filter *filters) lzma_nothrow lzma_attr_pure; diff --git a/project/jni/lzma/include/lzma/lzma.h b/project/jni/lzma/include/lzma/lzma.h index 8d5fdb6e5..3f8e095f7 100644 --- a/project/jni/lzma/include/lzma/lzma.h +++ b/project/jni/lzma/include/lzma/lzma.h @@ -412,6 +412,9 @@ typedef struct { * * This function is available only if LZMA1 or LZMA2 encoder has been enabled * when building liblzma. + * + * \return On success, false is returned. If the preset is not + * supported, true is returned. */ extern LZMA_API(lzma_bool) lzma_lzma_preset( lzma_options_lzma *options, uint32_t preset) lzma_nothrow; diff --git a/project/jni/lzma/include/lzma/version.h b/project/jni/lzma/include/lzma/version.h index 25e8a8201..beec18e20 100644 --- a/project/jni/lzma/include/lzma/version.h +++ b/project/jni/lzma/include/lzma/version.h @@ -22,7 +22,7 @@ */ #define LZMA_VERSION_MAJOR 5 #define LZMA_VERSION_MINOR 0 -#define LZMA_VERSION_PATCH 0 +#define LZMA_VERSION_PATCH 7 #define LZMA_VERSION_STABILITY LZMA_VERSION_STABILITY_STABLE #ifndef LZMA_VERSION_COMMIT diff --git a/project/jni/lzma/src/common/sysdefs.h b/project/jni/lzma/src/common/sysdefs.h index c74c6212c..5ea6bdae4 100644 --- a/project/jni/lzma/src/common/sysdefs.h +++ b/project/jni/lzma/src/common/sysdefs.h @@ -65,6 +65,9 @@ #ifndef PRIu32 # define PRIu32 "u" #endif +#ifndef PRIx32 +# define PRIx32 "x" +#endif #ifndef PRIX32 # define PRIX32 "X" #endif @@ -76,6 +79,9 @@ # ifndef PRIu64 # define PRIu64 "llu" # endif +# ifndef PRIx64 +# define PRIx64 "llx" +# endif # ifndef PRIX64 # define PRIX64 "llX" # endif @@ -86,6 +92,9 @@ # ifndef PRIu64 # define PRIu64 "lu" # endif +# ifndef PRIx64 +# define PRIx64 "lx" +# endif # ifndef PRIX64 # define PRIX64 "lX" # endif @@ -94,9 +103,12 @@ # define UINT64_MAX UINT64_C(18446744073709551615) #endif -// Interix has broken header files, which typedef size_t to unsigned long, -// but a few lines later define SIZE_MAX to INT32_MAX. -#ifdef __INTERIX +// Incorrect(?) SIZE_MAX: +// - Interix headers typedef size_t to unsigned long, +// but a few lines later define SIZE_MAX to INT32_MAX. +// - SCO OpenServer (x86) headers typedef size_t to unsigned int +// but define SIZE_MAX to INT32_MAX. +#if defined(__INTERIX) || defined(_SCO_DS) # undef SIZE_MAX #endif @@ -171,4 +183,10 @@ typedef unsigned char _Bool; # define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) #endif +#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) || __GNUC__ > 4 +# define lzma_attr_alloc_size(x) __attribute__((__alloc_size__(x))) +#else +# define lzma_attr_alloc_size(x) +#endif + #endif diff --git a/project/jni/lzma/src/common/tuklib_open_stdxxx.c b/project/jni/lzma/src/common/tuklib_open_stdxxx.c index 08bc60d8c..26702a6af 100644 --- a/project/jni/lzma/src/common/tuklib_open_stdxxx.c +++ b/project/jni/lzma/src/common/tuklib_open_stdxxx.c @@ -39,12 +39,14 @@ tuklib_open_stdxxx(int err_status) | (i == 0 ? O_WRONLY : O_RDONLY)); if (fd != i) { + if (fd != -1) + (void)close(fd); + // Something went wrong. Exit with the // exit status we were given. Don't try // to print an error message, since stderr // may very well be non-existent. This // error should be extremely rare. - (void)close(fd); exit(err_status); } } diff --git a/project/jni/lzma/src/liblzma/check/crc32_fast.c b/project/jni/lzma/src/liblzma/check/crc32_fast.c index 94da85592..3de02638d 100644 --- a/project/jni/lzma/src/liblzma/check/crc32_fast.c +++ b/project/jni/lzma/src/liblzma/check/crc32_fast.c @@ -20,7 +20,7 @@ #include "crc_macros.h" -// If you make any changes, do some bench marking! Seemingly unrelated +// If you make any changes, do some benchmarking! Seemingly unrelated // changes can very easily ruin the performance (and very probably is // very compiler dependent). extern LZMA_API(uint32_t) diff --git a/project/jni/lzma/src/liblzma/check/crc32_small.c b/project/jni/lzma/src/liblzma/check/crc32_small.c new file mode 100644 index 000000000..5f8a32868 --- /dev/null +++ b/project/jni/lzma/src/liblzma/check/crc32_small.c @@ -0,0 +1,61 @@ +/////////////////////////////////////////////////////////////////////////////// +// +/// \file crc32_small.c +/// \brief CRC32 calculation (size-optimized) +// +// Author: Lasse Collin +// +// This file has been put into the public domain. +// You can do whatever you want with this file. +// +/////////////////////////////////////////////////////////////////////////////// + +#include "check.h" + + +uint32_t lzma_crc32_table[1][256]; + + +static void +crc32_init(void) +{ + static const uint32_t poly32 = UINT32_C(0xEDB88320); + + for (size_t b = 0; b < 256; ++b) { + uint32_t r = b; + for (size_t i = 0; i < 8; ++i) { + if (r & 1) + r = (r >> 1) ^ poly32; + else + r >>= 1; + } + + lzma_crc32_table[0][b] = r; + } + + return; +} + + +extern void +lzma_crc32_init(void) +{ + mythread_once(crc32_init); + return; +} + + +extern LZMA_API(uint32_t) +lzma_crc32(const uint8_t *buf, size_t size, uint32_t crc) +{ + lzma_crc32_init(); + + crc = ~crc; + + while (size != 0) { + crc = lzma_crc32_table[0][*buf++ ^ (crc & 0xFF)] ^ (crc >> 8); + --size; + } + + return ~crc; +} diff --git a/project/jni/lzma/src/liblzma/check/crc32_tablegen.c b/project/jni/lzma/src/liblzma/check/crc32_tablegen.c new file mode 100644 index 000000000..31a4d2751 --- /dev/null +++ b/project/jni/lzma/src/liblzma/check/crc32_tablegen.c @@ -0,0 +1,117 @@ +/////////////////////////////////////////////////////////////////////////////// +// +/// \file crc32_tablegen.c +/// \brief Generate crc32_table_le.h and crc32_table_be.h +/// +/// Compiling: gcc -std=c99 -o crc32_tablegen crc32_tablegen.c +/// Add -DWORDS_BIGENDIAN to generate big endian table. +/// Add -DLZ_HASH_TABLE to generate lz_encoder_hash_table.h (little endian). +// +// Author: Lasse Collin +// +// This file has been put into the public domain. +// You can do whatever you want with this file. +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include "../../common/tuklib_integer.h" + + +static uint32_t crc32_table[8][256]; + + +static void +init_crc32_table(void) +{ + static const uint32_t poly32 = UINT32_C(0xEDB88320); + + for (size_t s = 0; s < 8; ++s) { + for (size_t b = 0; b < 256; ++b) { + uint32_t r = s == 0 ? b : crc32_table[s - 1][b]; + + for (size_t i = 0; i < 8; ++i) { + if (r & 1) + r = (r >> 1) ^ poly32; + else + r >>= 1; + } + + crc32_table[s][b] = r; + } + } + +#ifdef WORDS_BIGENDIAN + for (size_t s = 0; s < 8; ++s) + for (size_t b = 0; b < 256; ++b) + crc32_table[s][b] = bswap32(crc32_table[s][b]); +#endif + + return; +} + + +static void +print_crc32_table(void) +{ + printf("/* This file has been automatically generated by " + "crc32_tablegen.c. */\n\n" + "const uint32_t lzma_crc32_table[8][256] = {\n\t{"); + + for (size_t s = 0; s < 8; ++s) { + for (size_t b = 0; b < 256; ++b) { + if ((b % 4) == 0) + printf("\n\t\t"); + + printf("0x%08" PRIX32, crc32_table[s][b]); + + if (b != 255) + printf(",%s", (b+1) % 4 == 0 ? "" : " "); + } + + if (s == 7) + printf("\n\t}\n};\n"); + else + printf("\n\t}, {"); + } + + return; +} + + +static void +print_lz_table(void) +{ + printf("/* This file has been automatically generated by " + "crc32_tablegen.c. */\n\n" + "const uint32_t lzma_lz_hash_table[256] = {"); + + for (size_t b = 0; b < 256; ++b) { + if ((b % 4) == 0) + printf("\n\t"); + + printf("0x%08" PRIX32, crc32_table[0][b]); + + if (b != 255) + printf(",%s", (b+1) % 4 == 0 ? "" : " "); + } + + printf("\n};\n"); + + return; +} + + +int +main(void) +{ + init_crc32_table(); + +#ifdef LZ_HASH_TABLE + print_lz_table(); +#else + print_crc32_table(); +#endif + + return 0; +} diff --git a/project/jni/lzma/src/liblzma/check/crc64_small.c b/project/jni/lzma/src/liblzma/check/crc64_small.c new file mode 100644 index 000000000..55d72316b --- /dev/null +++ b/project/jni/lzma/src/liblzma/check/crc64_small.c @@ -0,0 +1,53 @@ +/////////////////////////////////////////////////////////////////////////////// +// +/// \file crc64_small.c +/// \brief CRC64 calculation (size-optimized) +// +// Author: Lasse Collin +// +// This file has been put into the public domain. +// You can do whatever you want with this file. +// +/////////////////////////////////////////////////////////////////////////////// + +#include "check.h" + + +static uint64_t crc64_table[256]; + + +static void +crc64_init(void) +{ + static const uint64_t poly64 = UINT64_C(0xC96C5795D7870F42); + + for (size_t b = 0; b < 256; ++b) { + uint64_t r = b; + for (size_t i = 0; i < 8; ++i) { + if (r & 1) + r = (r >> 1) ^ poly64; + else + r >>= 1; + } + + crc64_table[b] = r; + } + + return; +} + + +extern LZMA_API(uint64_t) +lzma_crc64(const uint8_t *buf, size_t size, uint64_t crc) +{ + mythread_once(crc64_init); + + crc = ~crc; + + while (size != 0) { + crc = crc64_table[*buf++ ^ (crc & 0xFF)] ^ (crc >> 8); + --size; + } + + return ~crc; +} diff --git a/project/jni/lzma/src/liblzma/check/crc64_tablegen.c b/project/jni/lzma/src/liblzma/check/crc64_tablegen.c new file mode 100644 index 000000000..fddaa7ed1 --- /dev/null +++ b/project/jni/lzma/src/liblzma/check/crc64_tablegen.c @@ -0,0 +1,88 @@ +/////////////////////////////////////////////////////////////////////////////// +// +/// \file crc64_tablegen.c +/// \brief Generate crc64_table_le.h and crc64_table_be.h +/// +/// Compiling: gcc -std=c99 -o crc64_tablegen crc64_tablegen.c +/// Add -DWORDS_BIGENDIAN to generate big endian table. +// +// Author: Lasse Collin +// +// This file has been put into the public domain. +// You can do whatever you want with this file. +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include "../../common/tuklib_integer.h" + + +static uint64_t crc64_table[4][256]; + + +extern void +init_crc64_table(void) +{ + static const uint64_t poly64 = UINT64_C(0xC96C5795D7870F42); + + for (size_t s = 0; s < 4; ++s) { + for (size_t b = 0; b < 256; ++b) { + uint64_t r = s == 0 ? b : crc64_table[s - 1][b]; + + for (size_t i = 0; i < 8; ++i) { + if (r & 1) + r = (r >> 1) ^ poly64; + else + r >>= 1; + } + + crc64_table[s][b] = r; + } + } + +#ifdef WORDS_BIGENDIAN + for (size_t s = 0; s < 4; ++s) + for (size_t b = 0; b < 256; ++b) + crc64_table[s][b] = bswap64(crc64_table[s][b]); +#endif + + return; +} + + +static void +print_crc64_table(void) +{ + printf("/* This file has been automatically generated by " + "crc64_tablegen.c. */\n\n" + "const uint64_t lzma_crc64_table[4][256] = {\n\t{"); + + for (size_t s = 0; s < 4; ++s) { + for (size_t b = 0; b < 256; ++b) { + if ((b % 2) == 0) + printf("\n\t\t"); + + printf("UINT64_C(0x%016" PRIX64 ")", + crc64_table[s][b]); + + if (b != 255) + printf(",%s", (b+1) % 2 == 0 ? "" : " "); + } + + if (s == 3) + printf("\n\t}\n};\n"); + else + printf("\n\t}, {"); + } + + return; +} + + +int +main(void) +{ + init_crc64_table(); + print_crc64_table(); + return 0; +} diff --git a/project/jni/lzma/src/liblzma/check/sha256.c b/project/jni/lzma/src/liblzma/check/sha256.c index 04231dbae..f2cc0d71a 100644 --- a/project/jni/lzma/src/liblzma/check/sha256.c +++ b/project/jni/lzma/src/liblzma/check/sha256.c @@ -6,7 +6,6 @@ /// \todo Crypto++ has x86 ASM optimizations. They use SSE so if they /// are imported to liblzma, SSE instructions need to be used /// conditionally to keep the code working on older boxes. -/// We could also support using some external libary for SHA-256. // // This code is based on the code found from 7-Zip, which has a modified // version of the SHA-256 found from Crypto++ . @@ -81,7 +80,7 @@ static const uint32_t SHA256_K[64] = { static void -transform(uint32_t state[static 8], const uint32_t data[static 16]) +transform(uint32_t state[8], const uint32_t data[16]) { uint32_t W[16]; uint32_t T[8]; diff --git a/project/jni/lzma/src/liblzma/common/alone_decoder.c b/project/jni/lzma/src/liblzma/common/alone_decoder.c index 039b42859..c25112e68 100644 --- a/project/jni/lzma/src/liblzma/common/alone_decoder.c +++ b/project/jni/lzma/src/liblzma/common/alone_decoder.c @@ -26,6 +26,11 @@ struct lzma_coder_s { SEQ_CODE, } sequence; + /// If true, reject files that are unlikely to be .lzma files. + /// If false, more non-.lzma files get accepted and will give + /// LZMA_DATA_ERROR either immediately or after a few output bytes. + bool picky; + /// Position in the header fields size_t pos; @@ -46,7 +51,7 @@ struct lzma_coder_s { static lzma_ret alone_decode(lzma_coder *coder, - lzma_allocator *allocator lzma_attribute((unused)), + lzma_allocator *allocator lzma_attribute((__unused__)), 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, @@ -68,13 +73,13 @@ alone_decode(lzma_coder *coder, |= (size_t)(in[*in_pos]) << (coder->pos * 8); if (++coder->pos == 4) { - if (coder->options.dict_size != UINT32_MAX) { + if (coder->picky && coder->options.dict_size + != UINT32_MAX) { // A hack to ditch tons of false positives: // We allow only dictionary sizes that are // 2^n or 2^n + 2^(n-1). LZMA_Alone created // only files with 2^n, but accepts any - // dictionary size. If someone complains, this - // will be reconsidered. + // dictionary size. uint32_t d = coder->options.dict_size - 1; d |= d >> 2; d |= d >> 3; @@ -103,9 +108,9 @@ alone_decode(lzma_coder *coder, // Another hack to ditch false positives: Assume that // if the uncompressed size is known, it must be less - // than 256 GiB. Again, if someone complains, this - // will be reconsidered. - if (coder->uncompressed_size != LZMA_VLI_UNKNOWN + // than 256 GiB. + if (coder->picky + && coder->uncompressed_size != LZMA_VLI_UNKNOWN && coder->uncompressed_size >= (LZMA_VLI_C(1) << 38)) return LZMA_FORMAT_ERROR; @@ -189,7 +194,7 @@ alone_decoder_memconfig(lzma_coder *coder, uint64_t *memusage, extern lzma_ret lzma_alone_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, - uint64_t memlimit) + uint64_t memlimit, bool picky) { lzma_next_coder_init(&lzma_alone_decoder_init, next, allocator); @@ -208,6 +213,7 @@ lzma_alone_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, } next->coder->sequence = SEQ_PROPERTIES; + next->coder->picky = picky; next->coder->pos = 0; next->coder->options.dict_size = 0; next->coder->options.preset_dict = NULL; @@ -223,7 +229,7 @@ lzma_alone_decoder_init(lzma_next_coder *next, lzma_allocator *allocator, extern LZMA_API(lzma_ret) lzma_alone_decoder(lzma_stream *strm, uint64_t memlimit) { - lzma_next_strm_init(lzma_alone_decoder_init, strm, memlimit); + lzma_next_strm_init(lzma_alone_decoder_init, strm, memlimit, false); strm->internal->supported_actions[LZMA_RUN] = true; strm->internal->supported_actions[LZMA_FINISH] = true; diff --git a/project/jni/lzma/src/liblzma/common/alone_decoder.h b/project/jni/lzma/src/liblzma/common/alone_decoder.h index 70d0d2a0f..f666fc382 100644 --- a/project/jni/lzma/src/liblzma/common/alone_decoder.h +++ b/project/jni/lzma/src/liblzma/common/alone_decoder.h @@ -16,7 +16,8 @@ #include "common.h" -extern lzma_ret lzma_alone_decoder_init(lzma_next_coder *next, - lzma_allocator *allocator, uint64_t memlimit); +extern lzma_ret lzma_alone_decoder_init( + lzma_next_coder *next, lzma_allocator *allocator, + uint64_t memlimit, bool picky); #endif diff --git a/project/jni/lzma/src/liblzma/common/alone_encoder.c b/project/jni/lzma/src/liblzma/common/alone_encoder.c index d8c0170f0..eb1697e99 100644 --- a/project/jni/lzma/src/liblzma/common/alone_encoder.c +++ b/project/jni/lzma/src/liblzma/common/alone_encoder.c @@ -32,7 +32,7 @@ struct lzma_coder_s { static lzma_ret alone_encode(lzma_coder *coder, - lzma_allocator *allocator lzma_attribute((unused)), + lzma_allocator *allocator lzma_attribute((__unused__)), 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, @@ -103,7 +103,7 @@ alone_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, if (options->dict_size < LZMA_DICT_SIZE_MIN) return LZMA_OPTIONS_ERROR; - // Round up to to the next 2^n or 2^n + 2^(n - 1) depending on which + // Round up to the next 2^n or 2^n + 2^(n - 1) depending on which // one is the next unless it is UINT32_MAX. While the header would // allow any 32-bit integer, we do this to keep the decoder of liblzma // accepting the resulting files. diff --git a/project/jni/lzma/src/liblzma/common/auto_decoder.c b/project/jni/lzma/src/liblzma/common/auto_decoder.c index ae6c3e786..35c895fd1 100644 --- a/project/jni/lzma/src/liblzma/common/auto_decoder.c +++ b/project/jni/lzma/src/liblzma/common/auto_decoder.c @@ -54,7 +54,7 @@ auto_decode(lzma_coder *coder, lzma_allocator *allocator, coder->memlimit, coder->flags)); } else { return_if_error(lzma_alone_decoder_init(&coder->next, - allocator, coder->memlimit)); + allocator, coder->memlimit, true)); // If the application wants to know about missing // integrity check or about the check in general, we diff --git a/project/jni/lzma/src/liblzma/common/block_buffer_encoder.c b/project/jni/lzma/src/liblzma/common/block_buffer_encoder.c index a8f71c214..519c6a684 100644 --- a/project/jni/lzma/src/liblzma/common/block_buffer_encoder.c +++ b/project/jni/lzma/src/liblzma/common/block_buffer_encoder.c @@ -226,16 +226,23 @@ lzma_block_buffer_encode(lzma_block *block, lzma_allocator *allocator, const uint8_t *in, size_t in_size, uint8_t *out, size_t *out_pos, size_t out_size) { - // Sanity checks - if (block == NULL || block->filters == NULL - || (in == NULL && in_size != 0) || out == NULL + // Validate the arguments. + if (block == NULL || (in == NULL && in_size != 0) || out == NULL || out_pos == NULL || *out_pos > out_size) return LZMA_PROG_ERROR; - // Check the version field. + // The contents of the structure may depend on the version so + // check the version before validating the contents of *block. if (block->version != 0) return LZMA_OPTIONS_ERROR; + if ((unsigned int)(block->check) > LZMA_CHECK_ID_MAX + || block->filters == NULL) + return LZMA_PROG_ERROR; + + if (!lzma_check_is_supported(block->check)) + return LZMA_UNSUPPORTED_CHECK; + // Size of a Block has to be a multiple of four, so limit the size // here already. This way we don't need to check it again when adding // Block Padding. @@ -243,8 +250,7 @@ lzma_block_buffer_encode(lzma_block *block, lzma_allocator *allocator, // Get the size of the Check field. const size_t check_size = lzma_check_size(block->check); - if (check_size == UINT32_MAX) - return LZMA_PROG_ERROR; + assert(check_size != UINT32_MAX); // Reserve space for the Check field. if (out_size - *out_pos <= check_size) diff --git a/project/jni/lzma/src/liblzma/common/block_encoder.c b/project/jni/lzma/src/liblzma/common/block_encoder.c index ca5152357..1eeb502b7 100644 --- a/project/jni/lzma/src/liblzma/common/block_encoder.c +++ b/project/jni/lzma/src/liblzma/common/block_encoder.c @@ -144,7 +144,7 @@ block_encoder_end(lzma_coder *coder, lzma_allocator *allocator) static lzma_ret block_encoder_update(lzma_coder *coder, lzma_allocator *allocator, - const lzma_filter *filters lzma_attribute((unused)), + const lzma_filter *filters lzma_attribute((__unused__)), const lzma_filter *reversed_filters) { if (coder->sequence != SEQ_CODE) @@ -161,6 +161,11 @@ lzma_block_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, { lzma_next_coder_init(&lzma_block_encoder_init, next, allocator); + if (block == NULL) + return LZMA_PROG_ERROR; + + // The contents of the structure may depend on the version so + // check the version first. if (block->version != 0) return LZMA_OPTIONS_ERROR; diff --git a/project/jni/lzma/src/liblzma/common/common.c b/project/jni/lzma/src/liblzma/common/common.c index 0408e1532..b9e386027 100644 --- a/project/jni/lzma/src/liblzma/common/common.c +++ b/project/jni/lzma/src/liblzma/common/common.c @@ -35,7 +35,7 @@ lzma_version_string(void) // Memory allocation // /////////////////////// -extern void * lzma_attribute((malloc)) +extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1) lzma_alloc(size_t size, lzma_allocator *allocator) { // Some malloc() variants return NULL if called with size == 0. diff --git a/project/jni/lzma/src/liblzma/common/common.h b/project/jni/lzma/src/liblzma/common/common.h index 3a85168f1..45aba4f06 100644 --- a/project/jni/lzma/src/liblzma/common/common.h +++ b/project/jni/lzma/src/liblzma/common/common.h @@ -205,7 +205,7 @@ struct lzma_internal_s { /// Allocates memory extern void *lzma_alloc(size_t size, lzma_allocator *allocator) - lzma_attribute((malloc)); + lzma_attribute((__malloc__)) lzma_attr_alloc_size(1); /// Frees memory extern void lzma_free(void *ptr, lzma_allocator *allocator); diff --git a/project/jni/lzma/src/liblzma/common/filter_common.c b/project/jni/lzma/src/liblzma/common/filter_common.c index b157c6280..7c95b05f2 100644 --- a/project/jni/lzma/src/liblzma/common/filter_common.c +++ b/project/jni/lzma/src/liblzma/common/filter_common.c @@ -43,7 +43,7 @@ static const struct { .changes_size = true, }, #endif -#ifdef HAVE_DECODER_LZMA2 +#if defined(HAVE_ENCODER_LZMA2) || defined(HAVE_DECODER_LZMA2) { .id = LZMA_FILTER_LZMA2, .options_size = sizeof(lzma_options_lzma), @@ -52,7 +52,7 @@ static const struct { .changes_size = true, }, #endif -#ifdef HAVE_DECODER_X86 +#if defined(HAVE_ENCODER_X86) || defined(HAVE_DECODER_X86) { .id = LZMA_FILTER_X86, .options_size = sizeof(lzma_options_bcj), @@ -70,7 +70,7 @@ static const struct { .changes_size = false, }, #endif -#ifdef HAVE_DECODER_IA64 +#if defined(HAVE_ENCODER_IA64) || defined(HAVE_DECODER_IA64) { .id = LZMA_FILTER_IA64, .options_size = sizeof(lzma_options_bcj), diff --git a/project/jni/lzma/src/liblzma/common/index.c b/project/jni/lzma/src/liblzma/common/index.c index ddb9d3643..9af4bc19d 100644 --- a/project/jni/lzma/src/liblzma/common/index.c +++ b/project/jni/lzma/src/liblzma/common/index.c @@ -398,10 +398,13 @@ extern LZMA_API(lzma_index *) lzma_index_init(lzma_allocator *allocator) { lzma_index *i = index_init_plain(allocator); + if (i == NULL) + return NULL; + index_stream *s = index_stream_init(0, 0, 1, 0, allocator); - if (i == NULL || s == NULL) { - index_stream_end(s, allocator); + if (s == NULL) { lzma_free(i, allocator); + return NULL; } index_tree_append(&i->streams, &s->node); diff --git a/project/jni/lzma/src/liblzma/common/index_decoder.c b/project/jni/lzma/src/liblzma/common/index_decoder.c index a6bc650e0..83c8a3af1 100644 --- a/project/jni/lzma/src/liblzma/common/index_decoder.c +++ b/project/jni/lzma/src/liblzma/common/index_decoder.c @@ -56,10 +56,11 @@ struct lzma_coder_s { static lzma_ret index_decode(lzma_coder *coder, lzma_allocator *allocator, const uint8_t *restrict in, size_t *restrict in_pos, - size_t in_size, uint8_t *restrict out lzma_attribute((unused)), - size_t *restrict out_pos lzma_attribute((unused)), - size_t out_size lzma_attribute((unused)), - lzma_action action lzma_attribute((unused))) + size_t in_size, + uint8_t *restrict out lzma_attribute((__unused__)), + size_t *restrict out_pos lzma_attribute((__unused__)), + size_t out_size lzma_attribute((__unused__)), + lzma_action action lzma_attribute((__unused__))) { // Similar optimization as in index_encoder.c const size_t in_start = *in_pos; diff --git a/project/jni/lzma/src/liblzma/common/index_encoder.c b/project/jni/lzma/src/liblzma/common/index_encoder.c index c10d7afa0..45919f094 100644 --- a/project/jni/lzma/src/liblzma/common/index_encoder.c +++ b/project/jni/lzma/src/liblzma/common/index_encoder.c @@ -42,12 +42,13 @@ struct lzma_coder_s { static lzma_ret index_encode(lzma_coder *coder, - lzma_allocator *allocator lzma_attribute((unused)), - const uint8_t *restrict in lzma_attribute((unused)), - size_t *restrict in_pos lzma_attribute((unused)), - size_t in_size lzma_attribute((unused)), + lzma_allocator *allocator lzma_attribute((__unused__)), + const uint8_t *restrict in lzma_attribute((__unused__)), + size_t *restrict in_pos lzma_attribute((__unused__)), + size_t in_size lzma_attribute((__unused__)), uint8_t *restrict out, size_t *restrict out_pos, - size_t out_size, lzma_action action lzma_attribute((unused))) + size_t out_size, + lzma_action action lzma_attribute((__unused__))) { // Position where to start calculating CRC32. The idea is that we // need to call lzma_crc32() only once per call to index_encode(). diff --git a/project/jni/lzma/src/liblzma/common/stream_buffer_encoder.c b/project/jni/lzma/src/liblzma/common/stream_buffer_encoder.c index f727d8542..2450ee2e1 100644 --- a/project/jni/lzma/src/liblzma/common/stream_buffer_encoder.c +++ b/project/jni/lzma/src/liblzma/common/stream_buffer_encoder.c @@ -51,6 +51,9 @@ lzma_stream_buffer_encode(lzma_filter *filters, lzma_check check, || out_pos_ptr == NULL || *out_pos_ptr > out_size) return LZMA_PROG_ERROR; + if (!lzma_check_is_supported(check)) + return LZMA_UNSUPPORTED_CHECK; + // Note for the paranoids: Index encoder prevents the Stream from // getting too big and still being accepted with LZMA_OK, and Block // encoder catches if the input is too big. So we don't need to @@ -81,26 +84,32 @@ lzma_stream_buffer_encode(lzma_filter *filters, lzma_check check, out_pos += LZMA_STREAM_HEADER_SIZE; - // Block + // Encode a Block but only if there is at least one byte of input. lzma_block block = { .version = 0, .check = check, .filters = filters, }; - return_if_error(lzma_block_buffer_encode(&block, allocator, - in, in_size, out, &out_pos, out_size)); + if (in_size > 0) + return_if_error(lzma_block_buffer_encode(&block, allocator, + in, in_size, out, &out_pos, out_size)); // Index { - // Create an Index with one Record. + // Create an Index. It will have one Record if there was + // at least one byte of input to encode. Otherwise the + // Index will be empty. lzma_index *i = lzma_index_init(allocator); if (i == NULL) return LZMA_MEM_ERROR; - lzma_ret ret = lzma_index_append(i, allocator, - lzma_block_unpadded_size(&block), - block.uncompressed_size); + lzma_ret ret = LZMA_OK; + + if (in_size > 0) + ret = lzma_index_append(i, allocator, + lzma_block_unpadded_size(&block), + block.uncompressed_size); // If adding the Record was successful, encode the Index // and get its size which will be stored into Stream Footer. diff --git a/project/jni/lzma/src/liblzma/common/stream_encoder.c b/project/jni/lzma/src/liblzma/common/stream_encoder.c index 48d91da79..97a7a23a8 100644 --- a/project/jni/lzma/src/liblzma/common/stream_encoder.c +++ b/project/jni/lzma/src/liblzma/common/stream_encoder.c @@ -280,6 +280,7 @@ lzma_stream_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, next->end = &stream_encoder_end; next->update = &stream_encoder_update; + next->coder->filters[0].id = LZMA_VLI_UNKNOWN; next->coder->block_encoder = LZMA_NEXT_CODER_INIT; next->coder->index_encoder = LZMA_NEXT_CODER_INIT; next->coder->index = NULL; @@ -289,7 +290,6 @@ lzma_stream_encoder_init(lzma_next_coder *next, lzma_allocator *allocator, next->coder->sequence = SEQ_STREAM_HEADER; next->coder->block_options.version = 0; next->coder->block_options.check = check; - next->coder->filters[0].id = LZMA_VLI_UNKNOWN; // Initialize the Index lzma_index_end(next->coder->index, allocator); diff --git a/project/jni/lzma/src/liblzma/delta/delta_encoder.c b/project/jni/lzma/src/liblzma/delta/delta_encoder.c index ea1cc2cb0..15c7951e1 100644 --- a/project/jni/lzma/src/liblzma/delta/delta_encoder.c +++ b/project/jni/lzma/src/liblzma/delta/delta_encoder.c @@ -85,7 +85,7 @@ delta_encode(lzma_coder *coder, lzma_allocator *allocator, static lzma_ret delta_encoder_update(lzma_coder *coder, lzma_allocator *allocator, - const lzma_filter *filters_null lzma_attribute((unused)), + const lzma_filter *filters_null lzma_attribute((__unused__)), const lzma_filter *reversed_filters) { // Delta doesn't and will never support changing the options in diff --git a/project/jni/lzma/src/liblzma/liblzma.pc b/project/jni/lzma/src/liblzma/liblzma.pc deleted file mode 100644 index 36bbbbc0a..000000000 --- a/project/jni/lzma/src/liblzma/liblzma.pc +++ /dev/null @@ -1,19 +0,0 @@ -# -# Author: Lasse Collin -# -# This file has been put into the public domain. -# You can do whatever you want with this file. -# - -prefix=/usr/local -exec_prefix=${prefix} -libdir=${exec_prefix}/lib -includedir=${prefix}/include - -Name: liblzma -Description: General purpose data compression library -URL: http://tukaani.org/xz/ -Version: 5.0.0 -Cflags: -I${includedir} -Libs: -L${libdir} -llzma -Libs.private: diff --git a/project/jni/lzma/src/liblzma/lz/lz_decoder.c b/project/jni/lzma/src/liblzma/lz/lz_decoder.c index 2c5735512..d74085cf4 100644 --- a/project/jni/lzma/src/liblzma/lz/lz_decoder.c +++ b/project/jni/lzma/src/liblzma/lz/lz_decoder.c @@ -126,7 +126,7 @@ decode_buffer(lzma_coder *coder, static lzma_ret lz_decode(lzma_coder *coder, - lzma_allocator *allocator lzma_attribute((unused)), + lzma_allocator *allocator lzma_attribute((__unused__)), 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, diff --git a/project/jni/lzma/src/liblzma/lz/lz_encoder.c b/project/jni/lzma/src/liblzma/lz/lz_encoder.c index 273f577b6..e24069658 100644 --- a/project/jni/lzma/src/liblzma/lz/lz_encoder.c +++ b/project/jni/lzma/src/liblzma/lz/lz_encoder.c @@ -480,7 +480,7 @@ lz_encoder_end(lzma_coder *coder, lzma_allocator *allocator) static lzma_ret lz_encoder_update(lzma_coder *coder, lzma_allocator *allocator, - const lzma_filter *filters_null lzma_attribute((unused)), + const lzma_filter *filters_null lzma_attribute((__unused__)), const lzma_filter *reversed_filters) { if (coder->lz.options_update == NULL) diff --git a/project/jni/lzma/src/liblzma/lz/lz_encoder_hash.h b/project/jni/lzma/src/liblzma/lz/lz_encoder_hash.h index c398d7d05..342a333d1 100644 --- a/project/jni/lzma/src/liblzma/lz/lz_encoder_hash.h +++ b/project/jni/lzma/src/liblzma/lz/lz_encoder_hash.h @@ -39,7 +39,7 @@ // Endianness doesn't matter in hash_2_calc() (no effect on the output). #ifdef TUKLIB_FAST_UNALIGNED_ACCESS # define hash_2_calc() \ - const uint32_t hash_value = *(const uint16_t *)(cur); + const uint32_t hash_value = *(const uint16_t *)(cur) #else # define hash_2_calc() \ const uint32_t hash_value \ diff --git a/project/jni/lzma/src/liblzma/lzma/fastpos_tablegen.c b/project/jni/lzma/src/liblzma/lzma/fastpos_tablegen.c new file mode 100644 index 000000000..c97e6f411 --- /dev/null +++ b/project/jni/lzma/src/liblzma/lzma/fastpos_tablegen.c @@ -0,0 +1,56 @@ +/////////////////////////////////////////////////////////////////////////////// +// +/// \file fastpos_tablegen.c +/// \brief Generates the lzma_fastpos[] lookup table +/// +// Authors: Igor Pavlov +// Lasse Collin +// +// This file has been put into the public domain. +// You can do whatever you want with this file. +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include "fastpos.h" + + +int +main(void) +{ + uint8_t fastpos[1 << FASTPOS_BITS]; + + const uint8_t fast_slots = 2 * FASTPOS_BITS; + uint32_t c = 2; + + fastpos[0] = 0; + fastpos[1] = 1; + + for (uint8_t slot_fast = 2; slot_fast < fast_slots; ++slot_fast) { + const uint32_t k = 1 << ((slot_fast >> 1) - 1); + for (uint32_t j = 0; j < k; ++j, ++c) + fastpos[c] = slot_fast; + } + + printf("/* This file has been automatically generated " + "by fastpos_tablegen.c. */\n\n" + "#include \"common.h\"\n" + "#include \"fastpos.h\"\n\n" + "const uint8_t lzma_fastpos[1 << FASTPOS_BITS] = {"); + + for (size_t i = 0; i < (1 << FASTPOS_BITS); ++i) { + if (i % 16 == 0) + printf("\n\t"); + + printf("%3u", (unsigned int)(fastpos[i])); + + if (i != (1 << FASTPOS_BITS) - 1) + printf(","); + } + + printf("\n};\n"); + + return 0; +} diff --git a/project/jni/lzma/src/liblzma/lzma/lzma2_decoder.c b/project/jni/lzma/src/liblzma/lzma/lzma2_decoder.c index f38879ce1..3e42575d5 100644 --- a/project/jni/lzma/src/liblzma/lzma/lzma2_decoder.c +++ b/project/jni/lzma/src/liblzma/lzma/lzma2_decoder.c @@ -67,6 +67,10 @@ lzma2_decode(lzma_coder *restrict coder, lzma_dict *restrict dict, const uint32_t control = in[*in_pos]; ++*in_pos; + // End marker + if (control == 0x00) + return LZMA_STREAM_END; + if (control >= 0xE0 || control == 1) { // Dictionary reset implies that next LZMA chunk has // to set new properties. @@ -104,10 +108,6 @@ lzma2_decode(lzma_coder *restrict coder, lzma_dict *restrict dict, &coder->options); } } else { - // End marker - if (control == 0x00) - return LZMA_STREAM_END; - // Invalid control values if (control > 2) return LZMA_DATA_ERROR; diff --git a/project/jni/lzma/src/liblzma/lzma/lzma2_encoder.c b/project/jni/lzma/src/liblzma/lzma/lzma2_encoder.c index b48e0d689..992720ca6 100644 --- a/project/jni/lzma/src/liblzma/lzma/lzma2_encoder.c +++ b/project/jni/lzma/src/liblzma/lzma/lzma2_encoder.c @@ -374,7 +374,7 @@ lzma_lzma2_props_encode(const void *options, uint8_t *out) const lzma_options_lzma *const opt = options; uint32_t d = my_max(opt->dict_size, LZMA_DICT_SIZE_MIN); - // Round up to to the next 2^n - 1 or 2^n + 2^(n - 1) - 1 depending + // Round up to the next 2^n - 1 or 2^n + 2^(n - 1) - 1 depending // on which one is the next: --d; d |= d >> 2; diff --git a/project/jni/lzma/src/liblzma/lzma/lzma_encoder_presets.c b/project/jni/lzma/src/liblzma/lzma/lzma_encoder_presets.c index 21e427a8d..8484b7744 100644 --- a/project/jni/lzma/src/liblzma/lzma/lzma_encoder_presets.c +++ b/project/jni/lzma/src/liblzma/lzma/lzma_encoder_presets.c @@ -30,14 +30,16 @@ lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset) options->lp = LZMA_LP_DEFAULT; options->pb = LZMA_PB_DEFAULT; - options->dict_size = UINT32_C(1) << (uint8_t []){ - 18, 20, 21, 22, 22, 23, 23, 24, 25, 26 }[level]; + static const uint8_t dict_pow2[] + = { 18, 20, 21, 22, 22, 23, 23, 24, 25, 26 }; + options->dict_size = UINT32_C(1) << dict_pow2[level]; if (level <= 3) { options->mode = LZMA_MODE_FAST; options->mf = level == 0 ? LZMA_MF_HC3 : LZMA_MF_HC4; options->nice_len = level <= 1 ? 128 : 273; - options->depth = (uint8_t []){ 4, 8, 24, 48 }[level]; + static const uint8_t depths[] = { 4, 8, 24, 48 }; + options->depth = depths[level]; } else { options->mode = LZMA_MODE_NORMAL; options->mf = LZMA_MF_BT4; diff --git a/project/jni/lzma/src/liblzma/rangecoder/price_tablegen.c b/project/jni/lzma/src/liblzma/rangecoder/price_tablegen.c new file mode 100644 index 000000000..bf08ce39d --- /dev/null +++ b/project/jni/lzma/src/liblzma/rangecoder/price_tablegen.c @@ -0,0 +1,87 @@ +/////////////////////////////////////////////////////////////////////////////// +// +/// \file price_tablegen.c +/// \brief Probability price table generator +/// +/// Compiling: gcc -std=c99 -o price_tablegen price_tablegen.c +/// +// Authors: Igor Pavlov +// Lasse Collin +// +// This file has been put into the public domain. +// You can do whatever you want with this file. +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include "range_common.h" +#include "price.h" + + +static uint32_t rc_prices[RC_PRICE_TABLE_SIZE]; + + +static void +init_price_table(void) +{ + for (uint32_t i = (UINT32_C(1) << RC_MOVE_REDUCING_BITS) / 2; + i < RC_BIT_MODEL_TOTAL; + i += (UINT32_C(1) << RC_MOVE_REDUCING_BITS)) { + const uint32_t cycles_bits = RC_BIT_PRICE_SHIFT_BITS; + uint32_t w = i; + uint32_t bit_count = 0; + + for (uint32_t j = 0; j < cycles_bits; ++j) { + w *= w; + bit_count <<= 1; + + while (w >= (UINT32_C(1) << 16)) { + w >>= 1; + ++bit_count; + } + } + + rc_prices[i >> RC_MOVE_REDUCING_BITS] + = (RC_BIT_MODEL_TOTAL_BITS << cycles_bits) + - 15 - bit_count; + } + + return; +} + + +static void +print_price_table(void) +{ + printf("/* This file has been automatically generated by " + "price_tablegen.c. */\n\n" + "#include \"range_encoder.h\"\n\n" + "const uint8_t lzma_rc_prices[" + "RC_PRICE_TABLE_SIZE] = {"); + + const size_t array_size = sizeof(lzma_rc_prices) + / sizeof(lzma_rc_prices[0]); + for (size_t i = 0; i < array_size; ++i) { + if (i % 8 == 0) + printf("\n\t"); + + printf("%4" PRIu32, rc_prices[i]); + + if (i != array_size - 1) + printf(","); + } + + printf("\n};\n"); + + return; +} + + +int +main(void) +{ + init_price_table(); + print_price_table(); + return 0; +} diff --git a/project/jni/lzma/src/liblzma/simple/arm.c b/project/jni/lzma/src/liblzma/simple/arm.c index 8fcf64374..a84702ac6 100644 --- a/project/jni/lzma/src/liblzma/simple/arm.c +++ b/project/jni/lzma/src/liblzma/simple/arm.c @@ -15,7 +15,7 @@ static size_t -arm_code(lzma_simple *simple lzma_attribute((unused)), +arm_code(lzma_simple *simple lzma_attribute((__unused__)), uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size) { diff --git a/project/jni/lzma/src/liblzma/simple/armthumb.c b/project/jni/lzma/src/liblzma/simple/armthumb.c index eb6a69d12..4b49175fe 100644 --- a/project/jni/lzma/src/liblzma/simple/armthumb.c +++ b/project/jni/lzma/src/liblzma/simple/armthumb.c @@ -15,7 +15,7 @@ static size_t -armthumb_code(lzma_simple *simple lzma_attribute((unused)), +armthumb_code(lzma_simple *simple lzma_attribute((__unused__)), uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size) { diff --git a/project/jni/lzma/src/liblzma/simple/ia64.c b/project/jni/lzma/src/liblzma/simple/ia64.c index fd263d4ae..ce3692b98 100644 --- a/project/jni/lzma/src/liblzma/simple/ia64.c +++ b/project/jni/lzma/src/liblzma/simple/ia64.c @@ -15,7 +15,7 @@ static size_t -ia64_code(lzma_simple *simple lzma_attribute((unused)), +ia64_code(lzma_simple *simple lzma_attribute((__unused__)), uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size) { diff --git a/project/jni/lzma/src/liblzma/simple/powerpc.c b/project/jni/lzma/src/liblzma/simple/powerpc.c index aaa14f221..6f8351176 100644 --- a/project/jni/lzma/src/liblzma/simple/powerpc.c +++ b/project/jni/lzma/src/liblzma/simple/powerpc.c @@ -15,7 +15,7 @@ static size_t -powerpc_code(lzma_simple *simple lzma_attribute((unused)), +powerpc_code(lzma_simple *simple lzma_attribute((__unused__)), uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size) { diff --git a/project/jni/lzma/src/liblzma/simple/simple_coder.c b/project/jni/lzma/src/liblzma/simple/simple_coder.c index 06db86ec2..a02b039aa 100644 --- a/project/jni/lzma/src/liblzma/simple/simple_coder.c +++ b/project/jni/lzma/src/liblzma/simple/simple_coder.c @@ -35,9 +35,6 @@ copy_or_code(lzma_coder *coder, lzma_allocator *allocator, } else { // Call the next coder in the chain to provide us some data. - // We don't care about uncompressed_size here, because - // the next filter in the chain will do it for us (since - // we don't change the size of the data). const lzma_ret ret = coder->next.code( coder->next.coder, allocator, in, in_pos, in_size, @@ -110,7 +107,7 @@ simple_code(lzma_coder *coder, lzma_allocator *allocator, // filtered if the buffer sizes used by the application are reasonable. const size_t out_avail = out_size - *out_pos; const size_t buf_avail = coder->size - coder->pos; - if (out_avail > buf_avail) { + if (out_avail > buf_avail || buf_avail == 0) { // Store the old position so that we know from which byte // to start filtering. const size_t out_start = *out_pos; @@ -212,7 +209,7 @@ simple_coder_end(lzma_coder *coder, lzma_allocator *allocator) static lzma_ret simple_coder_update(lzma_coder *coder, lzma_allocator *allocator, - const lzma_filter *filters_null lzma_attribute((unused)), + const lzma_filter *filters_null lzma_attribute((__unused__)), const lzma_filter *reversed_filters) { // No update support, just call the next filter in the chain. diff --git a/project/jni/lzma/src/liblzma/simple/simple_private.h b/project/jni/lzma/src/liblzma/simple/simple_private.h index a69f82785..fcf9f7c19 100644 --- a/project/jni/lzma/src/liblzma/simple/simple_private.h +++ b/project/jni/lzma/src/liblzma/simple/simple_private.h @@ -22,8 +22,7 @@ struct lzma_coder_s { /// Next filter in the chain lzma_next_coder next; - /// True if the next coder in the chain has returned LZMA_STREAM_END - /// or if we have processed uncompressed_size bytes. + /// True if the next coder in the chain has returned LZMA_STREAM_END. bool end_was_reached; /// True if filter() should encode the data; false to decode. diff --git a/project/jni/lzma/src/liblzma/simple/sparc.c b/project/jni/lzma/src/liblzma/simple/sparc.c index 808a59aaa..8270d6ab1 100644 --- a/project/jni/lzma/src/liblzma/simple/sparc.c +++ b/project/jni/lzma/src/liblzma/simple/sparc.c @@ -15,7 +15,7 @@ static size_t -sparc_code(lzma_simple *simple lzma_attribute((unused)), +sparc_code(lzma_simple *simple lzma_attribute((__unused__)), uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size) {