*/
/*
- * Copyright (C) 2012, 2013 Biggers
+ * Copyright (C) 2012, 2013 Eric Biggers
*
* This file is part of wimlib, a library for working with WIM files.
*
* succeed.
*/
-#include "util.h"
-#include "lzx.h"
-#include "decompress.h"
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "wimlib.h"
+#include "wimlib/decompress.h"
+#include "wimlib/lzx.h"
+#include "wimlib/util.h"
+
#include <string.h>
/* Huffman decoding tables and maps from symbols to code lengths. */
struct lzx_tables {
u16 maintree_decode_table[(1 << LZX_MAINTREE_TABLEBITS) +
- (LZX_MAINTREE_NUM_SYMBOLS * 2)];
+ (LZX_MAINTREE_NUM_SYMBOLS * 2)]
+ _aligned_attribute(DECODE_TABLE_ALIGNMENT);
u8 maintree_lens[LZX_MAINTREE_NUM_SYMBOLS];
u16 lentree_decode_table[(1 << LZX_LENTREE_TABLEBITS) +
- (LZX_LENTREE_NUM_SYMBOLS * 2)];
+ (LZX_LENTREE_NUM_SYMBOLS * 2)]
+ _aligned_attribute(DECODE_TABLE_ALIGNMENT);
u8 lentree_lens[LZX_LENTREE_NUM_SYMBOLS];
u16 alignedtree_decode_table[(1 << LZX_ALIGNEDTREE_TABLEBITS) +
- (LZX_ALIGNEDTREE_NUM_SYMBOLS * 2)];
+ (LZX_ALIGNEDTREE_NUM_SYMBOLS * 2)]
+ _aligned_attribute(DECODE_TABLE_ALIGNMENT);
u8 alignedtree_lens[LZX_ALIGNEDTREE_NUM_SYMBOLS];
-};
+} _aligned_attribute(DECODE_TABLE_ALIGNMENT);
/*
* Reads a Huffman-encoded symbol using the pre-tree.
*/
-static inline int read_huffsym_using_pretree(struct input_bitstream *istream,
- const u16 pretree_decode_table[],
- const u8 pretree_lens[], unsigned *n)
+static inline int
+read_huffsym_using_pretree(struct input_bitstream *istream,
+ const u16 pretree_decode_table[],
+ const u8 pretree_lens[], unsigned *n)
{
return read_huffsym(istream, pretree_decode_table, pretree_lens,
LZX_PRETREE_NUM_SYMBOLS, LZX_PRETREE_TABLEBITS, n,
}
/* Reads a Huffman-encoded symbol using the main tree. */
-static inline int read_huffsym_using_maintree(struct input_bitstream *istream,
- const struct lzx_tables *tables,
- unsigned *n)
+static inline int
+read_huffsym_using_maintree(struct input_bitstream *istream,
+ const struct lzx_tables *tables,
+ unsigned *n)
{
return read_huffsym(istream, tables->maintree_decode_table,
tables->maintree_lens, LZX_MAINTREE_NUM_SYMBOLS,
}
/* Reads a Huffman-encoded symbol using the length tree. */
-static inline int read_huffsym_using_lentree(struct input_bitstream *istream,
- const struct lzx_tables *tables,
- unsigned *n)
+static inline int
+read_huffsym_using_lentree(struct input_bitstream *istream,
+ const struct lzx_tables *tables,
+ unsigned *n)
{
return read_huffsym(istream, tables->lentree_decode_table,
tables->lentree_lens, LZX_LENTREE_NUM_SYMBOLS,
}
/* Reads a Huffman-encoded symbol using the aligned offset tree. */
-static inline int read_huffsym_using_alignedtree(struct input_bitstream *istream,
- const struct lzx_tables *tables,
- unsigned *n)
+static inline int
+read_huffsym_using_alignedtree(struct input_bitstream *istream,
+ const struct lzx_tables *tables,
+ unsigned *n)
{
return read_huffsym(istream, tables->alignedtree_decode_table,
tables->alignedtree_lens,
* @num_lens: Number of length values to decode and return.
*
*/
-static int lzx_read_code_lens(struct input_bitstream *istream, u8 lens[],
- unsigned num_lens)
+static int
+lzx_read_code_lens(struct input_bitstream *istream, u8 lens[],
+ unsigned num_lens)
{
/* Declare the decoding table and length table for the pretree. */
u16 pretree_decode_table[(1 << LZX_PRETREE_TABLEBITS) +
unsigned num_zeroes;
unsigned code;
unsigned num_same;
- char value;
+ signed char value;
ret = read_huffsym_using_pretree(istream, pretree_decode_table,
pretree_lens, &tree_code);
&code);
if (ret != 0)
return ret;
- value = (char)*lens - (char)code;
+ value = (signed char)*lens - (signed char)code;
if (value < 0)
value += 17;
while (num_same--) {
}
break;
default: /* Difference from old length. */
- value = (char)*lens - (char)tree_code;
+ value = (signed char)*lens - (signed char)tree_code;
if (value < 0)
value += 17;
*lens = value;
* R0, R1, and R2 will be written (only for uncompressed
* blocks, which contain this information in the header)
*/
-static int lzx_read_block_header(struct input_bitstream *istream,
- unsigned *block_size_ret,
- unsigned *block_type_ret,
- struct lzx_tables *tables,
- struct lru_queue *queue)
+static int
+lzx_read_block_header(struct input_bitstream *istream,
+ unsigned *block_size_ret,
+ unsigned *block_type_ret,
+ struct lzx_tables *tables,
+ struct lru_queue *queue)
{
int ret;
unsigned block_type;
unsigned len;
ret = bitstream_ensure_bits(istream, 4);
- if (ret != 0) {
- ERROR("LZX input stream overrun");
+ if (ret) {
+ DEBUG("LZX input stream overrun");
return ret;
}
block_size = 32768;
} else {
ret = bitstream_read_bits(istream, 16, &block_size);
- if (ret != 0)
+ if (ret)
return ret;
block_size = le16_to_cpu(block_size);
}
ret = bitstream_read_bits(istream,
LZX_ALIGNEDTREE_ELEMENT_SIZE,
&len);
- if (ret != 0)
+ if (ret)
return ret;
tables->alignedtree_lens[i] = len;
}
LZX_ALIGNEDTREE_TABLEBITS,
tables->alignedtree_lens,
8);
- if (ret != 0) {
- ERROR("lzx_decompress(): Failed to make the decode "
+ if (ret) {
+ DEBUG("lzx_decompress(): Failed to make the decode "
"table for the aligned offset tree");
return ret;
}
* tree. */
ret = lzx_read_code_lens(istream, tables->maintree_lens,
LZX_NUM_CHARS);
- if (ret != 0) {
- ERROR("lzx_decompress(): Failed to read the code "
+ if (ret) {
+ DEBUG("lzx_decompress(): Failed to read the code "
"lengths for the first 256 elements of the "
"main tree");
return ret;
ret = lzx_read_code_lens(istream,
tables->maintree_lens + LZX_NUM_CHARS,
LZX_MAINTREE_NUM_SYMBOLS - LZX_NUM_CHARS);
- if (ret != 0) {
- ERROR("lzx_decompress(): Failed to read the path "
+ if (ret) {
+ DEBUG("lzx_decompress(): Failed to read the path "
"lengths for the remaining elements of the main "
"tree");
return ret;
LZX_MAINTREE_TABLEBITS,
tables->maintree_lens,
LZX_MAX_CODEWORD_LEN);
- if (ret != 0) {
- ERROR("lzx_decompress(): Failed to make the decode "
+ if (ret) {
+ DEBUG("lzx_decompress(): Failed to make the decode "
"table for the main tree");
return ret;
}
LZX_DEBUG("Reading path lengths for the length tree.");
ret = lzx_read_code_lens(istream, tables->lentree_lens,
LZX_LENTREE_NUM_SYMBOLS);
- if (ret != 0) {
- ERROR("lzx_decompress(): Failed to read the path "
+ if (ret) {
+ DEBUG("lzx_decompress(): Failed to read the path "
"lengths for the length tree");
return ret;
}
LZX_LENTREE_TABLEBITS,
tables->lentree_lens,
LZX_MAX_CODEWORD_LEN);
- if (ret != 0) {
- ERROR("lzx_decompress(): Failed to build the length "
+ if (ret) {
+ DEBUG("lzx_decompress(): Failed to build the length "
"Huffman tree");
return ret;
}
* *already* aligned, the correct thing to do is to throw away
* the next 16 bits. */
if (istream->bitsleft == 0) {
- if (istream->data_bytes_left < 14)
+ if (istream->data_bytes_left < 14) {
+ DEBUG("lzx_decompress(): Insufficient length in "
+ "uncompressed block");
return -1;
+ }
istream->data += 2;
istream->data_bytes_left -= 2;
} else {
- if (istream->data_bytes_left < 12)
+ if (istream->data_bytes_left < 12) {
+ DEBUG("lzx_decompress(): Insufficient length in "
+ "uncompressed block");
return -1;
+ }
istream->bitsleft = 0;
istream->bitbuf = 0;
}
* be read in lzx_decompress(). */
break;
default:
- ERROR("lzx_decompress(): Found invalid block");
+ DEBUG("lzx_decompress(): Found invalid block");
return -1;
}
*block_type_ret = block_type;
* - Match refers to data before the window.
* - The input bitstream ended unexpectedly.
*/
-static int lzx_decode_match(unsigned main_element, int block_type,
- unsigned bytes_remaining, u8 *window,
- unsigned window_pos,
- const struct lzx_tables *tables,
- struct lru_queue *queue,
- struct input_bitstream *istream)
+static int
+lzx_decode_match(unsigned main_element, int block_type,
+ unsigned bytes_remaining, u8 *window,
+ unsigned window_pos,
+ const struct lzx_tables *tables,
+ struct lru_queue *queue,
+ struct input_bitstream *istream)
{
unsigned length_header;
unsigned position_slot;
match_src = match_dest - match_offset;
if (match_len > bytes_remaining) {
- ERROR("lzx_decode_match(): Match of length %u bytes overflows "
+ DEBUG("lzx_decode_match(): Match of length %u bytes overflows "
"uncompressed block size", match_len);
return -1;
}
if (match_src < window) {
- ERROR("lzx_decode_match(): Match of length %u bytes references "
+ DEBUG("lzx_decode_match(): Match of length %u bytes references "
"data before window (match_offset = %u, window_pos = %u)",
match_len, match_offset, window_pos);
return -1;
return match_len;
}
-static void undo_call_insn_translation(u32 *call_insn_target, int input_pos,
- int32_t file_size)
+static void
+undo_call_insn_translation(u32 *call_insn_target, int input_pos,
+ s32 file_size)
{
- int32_t abs_offset;
- int32_t rel_offset;
+ s32 abs_offset;
+ s32 rel_offset;
abs_offset = le32_to_cpu(*call_insn_target);
if (abs_offset >= -input_pos && abs_offset < file_size) {
* Call instruction processing is supposed to take the file size as a parameter,
* as it is used in calculating the translated jump targets. But in WIM files,
* this file size is always the same (LZX_WIM_MAGIC_FILESIZE == 12000000).*/
-static void undo_call_insn_preprocessing(u8 uncompressed_data[],
- int uncompressed_data_len)
+static void
+undo_call_insn_preprocessing(u8 uncompressed_data[], int uncompressed_data_len)
{
for (int i = 0; i < uncompressed_data_len - 10; i++) {
if (uncompressed_data[i] == 0xe8) {
* @queue: The least-recently-used queue for match offsets.
* @istream: The input bitstream for the compressed literals.
*/
-static int lzx_decompress_block(int block_type, unsigned block_size,
- u8 *window,
- unsigned window_pos,
- const struct lzx_tables *tables,
- struct lru_queue *queue,
- struct input_bitstream *istream)
+static int
+lzx_decompress_block(int block_type, unsigned block_size,
+ u8 *window,
+ unsigned window_pos,
+ const struct lzx_tables *tables,
+ struct lru_queue *queue,
+ struct input_bitstream *istream)
{
unsigned main_element;
unsigned end;
while (window_pos < end) {
ret = read_huffsym_using_maintree(istream, tables,
&main_element);
- if (ret != 0)
+ if (ret)
return ret;
if (main_element < LZX_NUM_CHARS) {
return 0;
}
-/*
- * Decompresses a block of LZX-compressed data as used in the WIM file format.
- *
- * Note that this will NOT work unmodified for LZX as used in the cabinet
- * format, which is not the same as in the WIM format!
- *
- * @compressed_data: A pointer to the compressed data.
- *
- * @compressed_len: The length of the compressed data, in bytes.
- *
- * @uncompressed_data: A pointer to the buffer into which to write the
- * uncompressed data.
- *
- * @uncompressed_len: The length of the uncompressed data. It must be
- * 32768 bytes or less.
- *
- * Return 0 on success; non-zero on failure.
- */
-int lzx_decompress(const void *compressed_data, unsigned compressed_len,
- void *uncompressed_data, unsigned uncompressed_len)
+/* API function documented in wimlib.h */
+WIMLIBAPI int
+wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
+ void *uncompressed_data, unsigned uncompressed_len)
{
struct lzx_tables tables;
struct input_bitstream istream;
LZX_DEBUG("Reading block header.");
ret = lzx_read_block_header(&istream, &block_size,
&block_type, &tables, &queue);
- if (ret != 0)
+ if (ret)
return ret;
LZX_DEBUG("block_size = %u, window_pos = %u",
block_size, window_pos);
if (block_size > uncompressed_len - window_pos) {
- ERROR("lzx_decompress(): Expected a block size of at "
+ DEBUG("lzx_decompress(): Expected a block size of at "
"most %u bytes (found %u bytes)",
uncompressed_len - window_pos, block_size);
return -1;
&tables,
&queue,
&istream);
- if (ret != 0)
+ if (ret)
return ret;
if (tables.maintree_lens[0xe8] != 0)
e8_preprocessing_done = true;
case LZX_BLOCKTYPE_UNCOMPRESSED:
LZX_DEBUG("LZX_BLOCKTYPE_UNCOMPRESSED");
if (istream.data_bytes_left < block_size) {
- ERROR("Unexpected end of input when "
+ DEBUG("Unexpected end of input when "
"reading %u bytes from LZX bitstream "
"(only have %u bytes left)",
block_size, istream.data_bytes_left);