generic-library/isa-l
1
0
Fork 0
mirror of https://github.com/intel/isa-l.git synced 2024-12-12 09:23:50 +01:00
Code Issues Projects Releases Wiki Activity

igzip: Document inflate_huff_code data structure.

Browse Source 
Signed-off-by: Roy Oursler <roy.j.oursler@intel.com>
Reviewed-by: Greg Tucker <greg.b.tucker@intel.com>
This commit is contained in:
Roy Oursler 2016-07-06 14:38:44 -07:00 committed by Greg Tucker
parent 40b5104397
commit 5a7c97a930
2 changed files with 47 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
igzip/igzip_inflate.asm
View File

@ -17,11 +17,7 @@ default rel
%define DECODE_LOOKUP_SIZE 15
%endif
%if DECODE_LOOKUP_SIZE > 7
%define MAX_LONG_CODE (((2 << 8) + 1) * (2 << (15 - DECODE_LOOKUP_SIZE)) + 32)
%else
%define MAX_LONG_CODE (2 << (15 - DECODE_LOOKUP_SIZE)) + (2 << (8 + DECODE_LOOKUP_SIZE)) + 32
%endif
%define MAX_LONG_CODE (288 + (1 << (15 - DECODE_LOOKUP_SIZE)))
%define COPY_SIZE 16
%define COPY_LEN_MAX 258

56
include/inflate.h
View File

@ -18,14 +18,6 @@
# define DECODE_LOOKUP_SIZE 15
#endif
#if DECODE_LOOKUP_SIZE > 7
# define TMP1 ((2 << 8 ) + 1)
# define TMP2 (2 << (15 - DECODE_LOOKUP_SIZE))
# define MAX_LONG_CODE (TMP1 * TMP2 + 32)
#else
# define MAX_LONG_CODE (2 << (15 - DECODE_LOOKUP_SIZE)) + (2 << (8 + DECODE_LOOKUP_SIZE)) + 32
#endif
/* Buffer used to manage decompressed output */
struct inflate_out_buffer{
uint8_t *start_out;
@ -43,10 +35,54 @@ struct inflate_in_buffer{
int32_t read_in_length;
};
/* Data structure used to store a huffman code for fast look up */
/*
* Data structure used to store a Huffman code for fast lookup. It works by
* performing a lookup in small_code_lookup that hopefully yields the correct
* symbol. Otherwise a lookup into long_code_lookup is performed to find the
* correct symbol. The details of how this works follows:
*
* Let i be some index into small_code_lookup and let e be the associated
* element. Bit 15 in e is a flag. If bit 15 is not set, then index i contains
* a Huffman code for a symbol which has length at most DECODE_LOOKUP_SIZE. Bits
* 0 through 8 are the symbol associated with that code and bits 9 through 12 of
* e represent the number of bits in the code. If bit 15 is set, the i
* corresponds to the first DECODE_LOOKUP_SIZE bits of a Huffman code which has
* length longer than DECODE_LOOKUP_SIZE. In this case, bits 0 through 8
* represent an offset into long_code_lookup table and bits 9 through 12
* represent the maximum length of a Huffman code starting with the bits in the
* index i. The offset into long_code_lookup is for an array associated with all
* codes which start with the bits in i.
*
* The elements of long_code_lookup are in the same format as small_code_lookup,
* except bit 15 is never set. Let i be a number made up of DECODE_LOOKUP_SIZE
* bits. Then all Huffman codes which start with DECODE_LOOKUP_SIZE bits are
* stored in an array starting at index h in long_code_lookup. This index h is
* stored in bits 0 through 9 at index i in small_code_lookup. The index j is an
* index of this array if the number of bits contained in j and i is the number
* of bits in the longest huff_code starting with the bits of i. The symbol
* stored at index j is the symbol whose huffcode can be found in (j <<
* DECODE_LOOKUP_SIZE) | i. Note these arrays will be stored sorted in order of
* maximum Huffman code length.
*
* The following are explanations for sizes of the tables:
*
* Since small_code_lookup is a lookup on DECODE_LOOKUP_SIZE bits, it must have
* size 2^DECODE_LOOKUP_SIZE.
*
* Since deflate Huffman are stored such that the code size and the code value
* form an increasing function, At most 2^(15 - DECODE_LOOKUP_SIZE) - 1 elements
* of long_code_lookup duplicate an existing symbol. Since there are at most 285
* - DECODE_LOOKUP_SIZE possible symbols contained in long_code lookup. Rounding
* this to the nearest 16 byte boundary yields the size of long_code_lookup of
* 288 + 2^(15 - DECODE_LOOKUP_SIZE).
*
* Note that DECODE_LOOKUP_SIZE can be any length even though the offset in
* small_lookup_code is 9 bits long because the increasing relationship between
* code length and code value forces the maximum offset to be less than 288.
*/
struct inflate_huff_code{
uint16_t small_code_lookup[ 1 << (DECODE_LOOKUP_SIZE)];
uint16_t long_code_lookup[MAX_LONG_CODE];
uint16_t long_code_lookup[288 + (1 << (15 - DECODE_LOOKUP_SIZE))];
};
/* Structure contained current state of decompression of data */