| Network Working Group | Y. Collet |
| Internet-Draft | M. Kucherawy, Ed. |
| Intended status: Standards Track | |
| Expires: March 29, 2018 | September 25, 2017 |
Zstandard Compression and The application/zstd Media Type
draft-kucherawy-dispatch-zstd-00
Zstandard, or "zstd" (pronounced "zee standard"), is a data compression mechanism. This document describes the mechanism, and registers a media type to be used when transporting zstd-compressed via Multipurpose Internet Mail Extensions (MIME).
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."
This Internet-Draft will expire on March 29, 2018.
Copyright (c) 2017 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.
Zstandard, or "zstd" (pronounced "zee standard") is a data compression mechanism, akin to gzip [RFC1952].
This document describes the Zstandard format. Also, to enable the transport of a data object compressed with Zstandard, this document registers a media type that can be used to identify such content when it is used in a payload encoded using Multipurpose Internet Mail Extensions (MIME).
This section describes the Zstandard algorithm.
Zstandard compressed data is made of up one or more frames. Each frame is independent and can be decompressed indepedently of other frames. The decompressed content of multiple concatenated frames is the concatenation of each frame's decompressed content.
There are two frame formats defined for Zstandard: Zstandard frames and Skippable frames. Zstandard frames contain compressed data, while skippable frames contain no data and can be used for metadata.
+--------------------+------------+ | Magic_Number | 4 bytes | +--------------------+------------+ | Frame_Header | 2-14 bytes | +--------------------+------------+ | Data_Block | n bytes | +--------------------+------------+ | [More Data Blocks] | | +--------------------+------------+ | [Content Checksum] | 0-4 bytes | +--------------------+------------+
The structure of a single Zstandard frame is as follows:
+-------------------------+-----------+ | Frame_Header_Descriptor | 1 byte | +-------------------------+-----------+ | [Window_Descriptor] | 0-1 byte | +-------------------------+-----------+ | [Dictionary_ID] | 0-4 bytes | +-------------------------+-----------+ | [Frame_Content_Size] | 0-8 bytes | +-------------------------+-----------+
The frame header has a variable size, with a minimum of two bytes and up to 14 bytes depending on optional parameters. The structure of Frame_Header is as follows:
+------------+-------------------------+ | Bit Number | Field Name | +------------+-------------------------+ | 7-6 | Frame Content Size Flag | +------------+-------------------------+ | 5 | Single Segment Flag | +------------+-------------------------+ | 4 | (unused) | +------------+-------------------------+ | 3 | (reserved) | +------------+-------------------------+ | 2 | Content Checksum Flag | +------------+-------------------------+ | 1-0 | Dictionary ID Flag | +------------+-------------------------+
The first header's byte is called the Frame Header Descriptor. It describes which other fields are present. Decoding this byte is enough to tell the size of Frame_Header.
In this table, bit 7 is the highest bit, while bit 0 is the lowest one.
+----------------+--------+---+---+---+ | Flag_Value | 0 | 1 | 2 | 3 | +----------------+--------+---+---+---+ | FCS_Field_Size | 0 or 1 | 2 | 4 | 8 | +----------------+--------+---+---+---+
This is a two-bit flag (equivalent to Frame_Header_Descriptor left-shifted six bits) specifying whether Frame_Content_Size (the decompressed data size) is provided within the header. Flag_Value provides FCS_Field_Size, which is the number of bytes used by Frame_Content_Size according to the following table:
When Flag_Value is 0, FCS_Field_Size depends on Single_Segment_Flag: If Single_Segment_flag is set, Field_Size is 1. Otherwise, Field_Size is 0; Frame_Content_Size is not provided.
If this flag is set, data must be regenerated within a single continuous memory segment.
In this case, Window_Descriptor byte is skipped, but Frame_Content_Size is necessarily present. As a consequence, the decoder must allocate a memory segment of size equal or bigger than Frame_Content_Size.
In order to protect the decoder from unreasonable memory requirements, a decoder is allowed to reject a compressed frame that requests a memory size beyond the decoder's authorized range.
For broader compatibility, decoders are recommended to support memory sizes of at least 8 MB. This is only a recommendation; each decoder is free to support higher or lower limits, depending on local limitations.
The value of this bit should be set to zero. A decoder compliant with this specification version shall not interpret it. It might be used in a future version, to signal a property which is not mandatory to properly decode the frame.
This bit is reserved for some future feature. Its value must be zero. A decoder compliant with this specification version must ensure it is not set. This bit may be used in a future revision, to signal a feature that must be interpreted to decode the frame correctly.
If this flag is set, a 32-bits Content_Checksum will be present at the frame's end. See the description of Content_Checksum above.
+------------+---+---+---+---+ | Flag_Value | 0 | 1 | 2 | 3 | +------------+---+---+---+---+ | Field_Size | 0 | 1 | 2 | 4 | +------------+---+---+---+---+
This is a two-bit flag (= FHD & 3) indicating whether a dictionary ID is provided within the header. It also specifies the size of this field as Field_Size:
Provides guarantees on minimum memory buffer required to decompress a frame. This information is important for decoders to allocate enough memory.
+-------------+----------+----------+ | Bit numbers | 7-3 | 2-0 | +-------------+----------+----------+ | Field name | Exponent | Mantissa | +-------------+----------+----------+
The Window_Descriptor byte is optional. When Single_Segment_flag is set, Window_Descriptor is not present. In this case, Window_Size is Frame_Content_Size, which can be any value from 0 to 2^64-1 bytes (16 ExaBytes).
windowLog = 10 + Exponent; windowBase = 1 << windowLog; windowAdd = (windowBase / 8) * Mantissa; Window_Size = windowBase + windowAdd;
The minimum memory buffer size is called Window_Size. It is described by the following formulae:
The minimum Window_Size is 1 KB. The maximum Window_Size is (1<<41) + 7*(1<<38) bytes, which is 3.75 TB.
To properly decode compressed data, a decoder will need to allocate a buffer of at least Window_Size bytes.
In order to protect decoders from unreasonable memory requirements, a decoder is allowed to reject a compressed frame which requests a memory size beyond decoder's authorized range.
For improved interoperability, decoders are recommended to be compatible with Window_Size >= 8 MB, and encoders are recommended to not request more than 8 MB. It's merely a recommendation though, and decoders are free to support larger or lower limits, depending on local limitations.
This is a variable size field, which contains the ID of the dictionary required to properly decode the frame. This field is optional. When it's not present, it's up to the decoder to make sure it uses the correct dictionary.
Field size depends on Dictionary_ID_flag. One byte can represent an ID 0-255; two bytes can represent an ID 0-65535; four bytes can represent an ID 0-4294967295. Format is little-endian.
It is permitted to represent a small ID (for example 13) with a large four-byte dictionary ID, even if it is less efficient.
If the frame is going to be distributed in a private environment, any dictionary ID can be used. However, for public distribution of compressed frames using a dictionary, the following ranges are reserved and shall not be used:
+----------------+--------------+ | FCS Field Size | Range | +----------------+--------------+ | 0 | unknown | +----------------+--------------+ | 1 | 0 - 255 | +----------------+--------------+ | 2 | 256 - 65791 | +----------------+--------------+ | 4 | 0 - 2^32 - 1 | +----------------+--------------+ | 8 | 0 - 2^64 - 1 | +----------------+--------------+
This is the original (uncompressed) size. This information is optional. Frame_Content_Size uses a variable number of bytes, provided by FCS_Field_Size. FCS_Field_Size is provided by the value of Frame_Content_Size_flag. FCS_Field_Size can be equal to 0 (not present), 1, 2, 4 or 8 bytes.
Frame_Content_Size format is little-endian. When FCS_Field_Size is 1, 4 or 8 bytes, the value is read directly. When FCS_Field_Size is 2, the offset of 256 is added. It's allowed to represent a small size (for example 18) using any compatible variant.
After Magic_Number and Frame_Header, there are some number of blocks. Each frame must have at least one block, but there is no upper limit on the number of blocks per frame.
+--------------+---------------+ | Block_Header | Block_Content | +--------------+---------------+ | 3 bytes | n bytes | +--------------+---------------+
The structure of a block is as follows:
+------------+------------+------------+ | Last_Block | Block_Type | Block_Size | +------------+------------+------------+ | bit 0 | bits 1-2 | bits 3-23 | +------------+------------+------------+
Block_Header uses three bytes, written using little-endian convention. It contains three fields:
The lowest bit signals if this block is the last one. The frame will end after this last block. It may be followed by an optional Content_Checksum (see Section 2.1.1).
+-----------+------------------+ | Value | Block_Type | +-----------+------------------+ | 0 | Raw_Block | +-----------+------------------+ | 1 | RLE_Block | +-----------+------------------+ | 2 | Compressed_Block | +-----------+------------------+ | 3 | Reserved | +-----------+------------------+
The next two bits represent the Block_Type. There are four block types:
The upper 21 bits of Block_Header represent the Block_Size. Block sizes must respect a few rules:
A block can contain any number of bytes (even zero), up to Block_Maximum_Decompressed_Size, which is the smallest of:
To decompress a compressed block, the compressed size must be provided from Block_Size field within Block_Header.
A compressed block consists of two sections: a Literals Section (Section 2.1.1.3.1) and a Sequences Section (Section 2.1.1.3.2). The results of the two sections are then combined to produce the decompressed data in Sequence Execution (Section 2.2).
To decode a compressed block, the following elements are necessary:
All literals are regrouped in the first part of the block. They can be decoded first, and then copied during Sequence Execution (see Section 2.2), or they can be decoded on the flow during Sequence Execution.
+----------------------------+ | Literals_Section_Header | +----------------------------+ | [Huffman_Tree_Description] | +----------------------------+ | Stream 1 | +----------------------------+ | [Stream 2] | +----------------------------+ | [Stream 3] | +----------------------------+ | [Stream 4] | +----------------------------+
Literals can be stored uncompressed or compressed using Huffman prefix codes. When compressed, an optional tree description can be present, followed by one or four streams.
+---------------------+-----------+ | Literals_Block_Type | 2 bits | +---------------------+-----------+ | Size_Format | 1-2 bits | +---------------------+-----------+ | Regenerated_Size | 5-20 bits | +---------------------+-----------+ | [Compressed_Size] | 0-18 bits | +---------------------+-----------+
This field describes how literals are packed. It's a byte-aligned variable-size bitfield, ranging from one to five bytes, using little-endian convention.
In this representation, bits at the top are the lowest bits.
+---------------------------+-------+ | Literals_Block_Type | Value | +---------------------------+-------+ | Raw_Literals_Block | 0 | +---------------------------+-------+ | RLE_Literals_Block | 1 | +---------------------------+-------+ | Compressed_Literals_Block | 2 | +---------------------------+-------+ | Treeless_Literals_Block | 3 | +---------------------------+-------+
The Literals_Block_Type field uses the two lowest bits of the first byte, describing four different block types:
The Size_Format is divided into two families:
For values spanning several bytes, convention is little-endian.
Size_Format for Raw_Literals_Block and RLE_Literals_Block:
Only Stream1 is present for these cases. Note that it is permitted to represent a short value (for example 13) using a long format, even if it's less efficient.
Size_Format for Compressed_Literals_Block and Treeless_Literals_Block:
Both the Compressed_Size and Regenerated_Size fields follow little-endian convention. Note that Compressed_Size includes the size of the Huffman Tree description when it is present.
The data in Stream1 is Regenerated_Size bytes long. It contains the raw literals data to be used during Sequence Execution (Section 2.1.1.3.2).
Stream1 consists of a single byte which should be repeated Regenerated_Size times to generate the decoded literals.
Both of these modes contain Huffman encoded data. Treeless_Literals_Block does not have a Huffman_Tree_Description.
Total_Streams_Size = Compressed_Size
- Huffman_Tree_Description_Size
This section is only present when Literals_Block_Type type is Compressed_Literals_Block (2). The format of the Huffman tree description can be found in Section 2.4.2.1. The size of Huffman_Tree_Description is determined during the decoding process. It must be used to determine where streams begin. It is always true that:
For Treeless_Literals_Block, the Huffman table comes from previously compressed literals block.
Huffman compressed data consists of either one or four Huffman-coded streams.
If only one stream is present, it is a single bitstream occupying the entire remaining portion of the literals block, encoded as described within Section 2.4.2.2.
If there are four streams, the literals section header only provides enough information to know the decompressed and compressed sizes of all four streams combined. The decompressed size of each stream is equal to (Regenerated_Size+3)/4, except for the last stream which may be up to three bytes smaller, to reach a total decompressed size as specified in Regenerated_Size.
Stream4_Size = Total_Streams_Size - 6
- Stream1_Size - Stream2_Size
- Stream3_Size
The compressed size of each stream is provided explicitly: the first six bytes of the compressed data consist of three two-byte little-endian fields, describing the compressed sizes of the first three streams. Stream4_Size is computed from Total_Streams_Size minus sizes of other streams.
Note that Total_Streams_Size can be smaller than Compressed_Size in the header, because Compressed_Size also contains Huffman_Tree_Description_Size when it is present.
Each of these four bitstreams is then decoded independently as a Huffman-Coded stream, as described in Section 2.4.2.2.
A compressed block is a succession of sequences. A sequence is a literal copy command, followed by a match copy command. A literal copy command specifies a length. It is the number of bytes to be copied (or extracted) from the Literals Section. A match copy command specifies an offset and a length.
When all sequences are decoded, if there are literals left in the literal section, these bytes are added at the end of the block.
This is described in more detail in Section 2.2.
The Sequences_Section regroups all symbols required to decode commands. There are three symbol types: literals lengths, offsets, and match lengths. They are encoded together, interleaved, in a single "bitstream".
The Sequences_Section starts by a header, followed by optional probability tables for each symbol type, followed by the bitstream.
Sequences_Section_Header
[Literals_Length_Table]
[Offset_Table]
[Match_Length_Table]
bitStream
To decode the Sequences_Section, it's necessary to know its size. This size is deduced from Block_Size - Literals_Section_Size.
This header consists of two items:
Number_of_Sequences is a variable size field using between one and three bytes. If the first byte is "byte0":
+------------+----------------------+ | Bit Number | Field Name | +------------+----------------------+ | 7-6 | Literal_Lengths_Mode | +------------+----------------------+ | 5-4 | Offsets_Mode | +------------+----------------------+ | 3-2 | Match_Lengths_Mode | +------------+----------------------+ | 1-0 | Reserved | +------------+----------------------+
Symbol_Compression_Modes is a single byte, defining the compression mode of each symbol type.
The last field, Reserved, must be all zeroes.
+-------+---------------------+ | Value | Compression_Mode | +-------+---------------------+ | 0 | Predefined_Mode | +-------+---------------------+ | 1 | RLE_Mode | +-------+---------------------+ | 2 | FSE_Compressed_Mode | +-------+---------------------+ | 3 | Repeat_Mode | +-------+---------------------+
Literals_Lengths_Mode, Offsets_Mode, and Match_Lengths_Mode define the Compression_Mode of literals lengths, offsets, and match lengths symbols respectively. They follow the same enumeration:
Each symbol is a code in its own context, which specifies Baseline and Number_of_Bits to add. Codes are FSE compressed, and interleaved with raw additional bits in the same bitstream.
+----------------------+----------+----------------+ | Literals_Length_Code | Baseline | Number_of_Bits | +----------------------+----------+----------------+ | 0-15 | length | 0 | +----------------------+----------+----------------+ | 16 | 16 | 1 | +----------------------+----------+----------------+ | 17 | 18 | 1 | +----------------------+----------+----------------+ | 18 | 20 | 1 | +----------------------+----------+----------------+ | 19 | 22 | 1 | +----------------------+----------+----------------+ | 20 | 24 | 2 | +----------------------+----------+----------------+ | 21 | 28 | 2 | +----------------------+----------+----------------+ | 22 | 32 | 3 | +----------------------+----------+----------------+ | 23 | 40 | 3 | +----------------------+----------+----------------+ | 24 | 48 | 4 | +----------------------+----------+----------------+ | 25 | 64 | 6 | +----------------------+----------+----------------+ | 26 | 128 | 7 | +----------------------+----------+----------------+ | 27 | 256 | 8 | +----------------------+----------+----------------+ | 28 | 512 | 9 | +----------------------+----------+----------------+ | 29 | 1024 | 10 | +----------------------+----------+----------------+ | 30 | 2048 | 11 | +----------------------+----------+----------------+ | 31 | 4096 | 12 | +----------------------+----------+----------------+ | 32 | 8192 | 13 | +----------------------+----------+----------------+ | 33 | 16384 | 14 | +----------------------+----------+----------------+ | 34 | 32768 | 15 | +----------------------+----------+----------------+ | 35 | 65536 | 16 | +----------------------+----------+----------------+
Literals length codes are values ranging from 0 to 35 inclusive. They define lengths from 0 to 131071 bytes. The literals length is equal to the decoded Baseline plus the result of reading Number_of_Bits bits from the bitstream, as a little-endian value.
+-------------------+----------+----------------+ | Match_Length_Code | Baseline | Number_of_Bits | +-------------------+----------+----------------+ | 0-31 | length | 0 | +-------------------+----------+----------------+ | 32 | 35 | 1 | +-------------------+----------+----------------+ | 33 | 37 | 1 | +-------------------+----------+----------------+ | 34 | 39 | 1 | +-------------------+----------+----------------+ | 35 | 41 | 1 | +-------------------+----------+----------------+ | 36 | 43 | 2 | +-------------------+----------+----------------+ | 37 | 47 | 2 | +-------------------+----------+----------------+ | 38 | 51 | 3 | +-------------------+----------+----------------+ | 39 | 59 | 3 | +-------------------+----------+----------------+ | 40 | 67 | 4 | +-------------------+----------+----------------+ | 41 | 83 | 4 | +-------------------+----------+----------------+ | 42 | 99 | 5 | +-------------------+----------+----------------+ | 43 | 131 | 7 | +-------------------+----------+----------------+ | 44 | 259 | 8 | +-------------------+----------+----------------+ | 45 | 515 | 9 | +-------------------+----------+----------------+ | 46 | 1027 | 10 | +-------------------+----------+----------------+ | 47 | 2051 | 11 | +-------------------+----------+----------------+ | 48 | 4099 | 12 | +-------------------+----------+----------------+ | 49 | 8195 | 13 | +-------------------+----------+----------------+ | 50 | 16387 | 14 | +-------------------+----------+----------------+ | 51 | 32771 | 15 | +-------------------+----------+----------------+ | 52 | 65539 | 16 | +-------------------+----------+----------------+
Match length codes are values ranging from 0 to 52 included. They define lengths from 3 to 131074 bytes. The match length is equal to the decoded Baseline plus the result of reading Number_of_Bits bits from the bitstream, as a little-endian value.
Offset codes are values ranging from 0 to N.
A decoder is free to limit its maximum supported value for N. Support for values of at least 22 is recommended. At the time of this writing, the reference decoder supports a maximum N value of 28 in 64-bits mode.
Offset_Value = (1 << offsetCode) + readNBits(offsetCode); if (Offset_Value > 3) offset = Offset_Value - 3;
An offset code is also the number of additional bits to read in little-endian fashion, and can be translated into an Offset_Value using the following formulas:
This means that maximum Offset_Value is (2^(N+1))-1 and it supports back-reference distance up to (2^(N+1))-4 but is limited by maximum back-reference distance (see Section 2.1.1.1.2).
Offset_Value from 1 to 3 are special: they define "repeat codes". This is described in more detail in Repeat Offsets.
FSE bitstreams are read in reverse direction than written. In zstd, the compressor writes bits forward into a block and the decompressor must read the bitstream backwards.
To find the start of the bitstream it is therefore necessary to know the offset of the last byte of the block which can be found by counting Block_Size bytes after the block header.
After writing the last bit containing information, the compressor writes a single 1-bit and then fills the byte with 0-7 zero bits of padding. The last byte of the compressed bitstream cannot be zero for that reason.
When decompressing, the last byte containing the padding is the first byte to read. The decompressor needs to skip 0-7 initial zero bits until the first one bit occurs. Afterwards, the useful part of the bitstream begins.
FSE decoding requires a 'state' to be carried from symbol to symbol. For more explanation on FSE decoding, see Section 2.4.1.
For sequence decoding, a separate state keeps track of each literal lengths, offsets, and match lengths symbols. Some FSE primitives are also used. For more details on the operation of these primitives, see Section 2.4.1.
The bitstream starts with initial FSE state values, each using the required number of bits in their respective accuracy, decoded previously from their normalized distribution. It starts with Literals_Length_State, followed by Offset_State, and finally Match_Length_State.
Note that all values are read backward, so the 'start' of the bitstream is at the highest position in memory, immediately before the last one bit for padding.
After decoding the starting states, a single sequence is decoded Number_Of_Sequences times. These sequences are decoded in order from first to last. Since the compressor writes the bitstream in the forward direction, this means the compressor must encode the sequences starting with the last one and ending with the first.
For each of the symbol types, the FSE state can be used to determine the appropriate code. The code then defines the baseline and number of bits to read for each type. The description of the codes for how to determine these values was presented earlier.
Decoding starts by reading the Number_of_Bits required to decode Offset. It then does the same for Match_Length, and then for Literals_Length. This sequence is then used for sequence execution (see Section 2.2).
If it is not the last sequence in the block, the next operation is to update states. Using the rules pre-calculated in the decoding tables, Literals_Length_State is updated, followed by Match_Length_State, and then Offset_State. See Section 2.4.1 for details on how to update states from the bitstream.
This operation will be repeated Number_of_Sequences times. At the end, the bitstream shall be entirely consumed, otherwise the bitstream is considered corrupted.
If Predefined_Mode is selected for a symbol type, its FSE decoding table is generated from a predefined distribution table defined here. For details on how to convert this distribution into a decoding table, see Section 2.4.1.
short literalsLength_defaultDistribution[36] =
{ 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
-1,-1,-1,-1
};
The decoding table uses an accuracy log of 6 bits (64 states).
short matchLengths_defaultDistribution[53] =
{ 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,
-1,-1,-1,-1,-1
};
The decoding table uses an accuracy log of 6 bits (64 states).
The decoding table uses an accuracy log of 5 bits (32 states), and supports a maximum N value of 28, allowing offset values up to 536,870,908.
short offsetCodes_defaultDistribution[29] =
{ 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1
};
If any sequence in the compressed block requires a larger offset than this, it's not possible to use the default distribution to represent it.
Once literals and sequences have been decoded, they are combined to produce the decoded content of a block.
Each sequence consists of a tuple of (literals_length, offset_value, match_length), decoded as described in the Sequences Section (Section 2.1.1.3.2). To execute a sequence, first copy literals_length bytes from the literals section to the output.
Then match_length bytes are copied from previous decoded data. The offset to copy from is determined by offset_value:
The offset is defined as from the current position, so an offset of 6 and a match length of 3 means that 3 bytes should be copied from 6 bytes back. Note that all offsets leading to previously decoded data must be smaller than Window_Size defined in Frame_Header_Descriptor (Section 2.1.1.1.1).
As seen above, the first three values define a repeated offset and we will call them Repeated_Offset1, Repeated_Offset2, and Repeated_Offset3. They are sorted in recency order, with Repeated_Offset1 meaning "most recent one".
If offset_value is 1, then the offset used is Repeated_Offset1, etc.
There is one exception: When the current sequence's literals_length is 0, repeated offsets are shifted by one, so an offset_value of 1 means Repeated_Offset2, an offset_value of 2 means Repeated_Offset3, and an offset_value of 3 means Repeated_Offset1 - 1_byte.
For the first block, the starting offset history is populated with the following values : 1, 4 and 8 (in order).
Then each block gets its starting offset history from the ending values of the most recent Compressed_Block. Note that blocks that are not Compressed_Block are skipped; they do not contribute to offset history.
The newest offset takes the lead in offset history, shifting others back (up to its previous place if it was already present). This means that when Repeated_Offset1 (most recent) is used, history is unmodified. When Repeated_Offset2 is used, it is swapped with Repeated_Offset1. If any other offset is used, it becomes Repeated_Offset1 and the rest are shifted back by one.
+--------------+------------+-----------+ | Magic_Number | Frame_Size | User_Data | +--------------+------------+-----------+ | 4 bytes | 4 bytes | n bytes | +--------------+------------+-----------+
Skippable frames allow the insertion of user-defined data into a flow of concatenated frames. Its design is pretty straightforward, with the sole objective to allow the decoder to quickly skip over user-defined data and continue decoding.
Skippable frames defined in this specification are compatible with skippable frames in [LZ4].
The fields are:
Two types of entropy encoding are used by the Zstandard format: FSE, and Huffman coding.
FSE, short for Finite State Entropy, is an entropy codec based on [ANS]. FSE encoding/decoding involves a state that is carried over between symbols, so decoding must be done in the opposite direction as encoding. Therefore, all FSE bitstreams are read from end to beginning.
For additional details on FSE, see Finite State Entropy [FSE].
FSE decoding involves a decoding table that has a power of two size, and contains three elements: Symbol, Num_Bits, and Baseline. The base two logarithm of the table size is its Accuracy_Log. The FSE state represents an index in this table.
To obtain the initial state value, consume Accuracy_Log bits from the stream as a little-endian value. The next symbol in the stream is the Symbol indicated in the table for that state. To obtain the next state value, the decoder should consume Num_Bits bits from the stream as a little-endian value and add it to Baseline.
To decode FSE streams, it is necessary to construct the decoding table. The Zstandard format encodes FSE table descriptions as described here.
An FSE distribution table describes the probabilities of all symbols from 0 to the last present one (included) on a normalized scale of (1 << Accuracy_Log), meaning a binary 1 left-shifted Accuracy_Log bits.
A bitstream is read forward, in little-endian fashion. It is not necessary to know its exact size, since the size will be discovered and reported by the decoding process. The bitstream starts by reporting on which scale it operates. Note that Accuracy_Log = low4bits + 5.
+------------+---------------+-----------+ | Value read | Value decoded | Bits used | +------------+---------------+-----------+ | 0 - 98 | 0 - 98 | 7 | +------------+---------------+-----------+ | 99 - 127 | 99 - 127 | 8 | +------------+---------------+-----------+ | 128 - 226 | 0 - 98 | 7 | +------------+---------------+-----------+ | 227 - 255 | 128 - 156 | 8 | +------------+---------------+-----------+
This is followed by each symbol value, from 0 to the last present one. The number of bits used by each field is variable and depends on:
Symbol probabilities are read one by one, in order. The probability is obtained from Value decoded using the formula P = Value - 1. This means the value 0 becomes the negative probability -1. This is a special probability that means "less than 1". Its effect on the distribution table is described below. For the purpose of calculating total allocated probability points, it counts as 1.
When a symbol has a probability of zero, it is followed by a 2-bit repeat flag. This repeat flag tells how many probabilities of zeroes follow the current one. It provides a number ranging from 0 to 3. If it is a 3, another 2-bit repeat flag follows, and so on.
When the last symbol reaches a cumulated total of (1 << Accuracy_Log), decoding is complete. If the last symbol makes the cumulated total go above (1 << Accuracy_Log), distribution is considered corrupted.
Finally, the decoder can tell how many bytes were used in this process, and how many symbols are present. The bitstream consumes a round number of bytes. Any remaining bit within the last byte is simply unused.
The distribution of normalized probabilities is enough to create a unique decoding table. The table has a size of (1 << Accuracy_Log). Each cell describes the symbol decoded, and instructions to get the next state.
Symbols are scanned in their natural order for "less than 1" probabilities as described above. Symbols with this probability are being attributed a single cell, starting from the end of the table. These symbols define a full state reset, reading Accuracy_Log bits.
position += (tableSize >> 1) + (tableSize >> 3) + 3; position &= tableSize - 1;
All remaining symbols are sorted in their natural order. Starting from symbol 0 and table position 0, each symbol gets attributed as many cells as its probability. Cell allocation is non-linear linear; each successor position follow this rule:
A position is skipped if it is already occupied by a "less than 1" probability symbol. Position does not reset between symbols; it simply iterates through each position in the table, switching to the next symbol when enough states have been allocated to the current one.
The result is a list of state values. Each state will decode the current symbol.
To get the Number_of_Bits and Baseline required for the next state, it is first necessary to sort all states in their natural order. The lower states will need one more bit than higher ones.
For example, presuming a symbol has a probability of 5, it receives five state values. States are sorted in natural order. The next power of two is 8. The space of probabilities is divided into 8 equal parts. Presuming the Accuracy_Log is 7, this defines 128 states, and each share (divided by 8) is 16 in size. In order to reach 8, 8 - 5 = 3 lowest states will count "double", doubling the number of shares, requiring one more bit in the process.
Numbering starts from higher states using fewer bits.
+----------------+-------+-------+--------+------+-------+ | state order | 0 | 1 | 2 | 3 | 4 | +----------------+-------+-------+--------+------+-------+ | width | 32 | 32 | 32 | 16 | 16 | +----------------+-------+-------+--------+------+-------+ | Number_of_Bits | 5 | 5 | 5 | 4 | 4 | +----------------+-------+-------+--------+------+-------+ | range number | 2 | 4 | 6 | 0 | 1 | +----------------+-------+-------+--------+------+-------+ | Baseline | 32 | 64 | 96 | 0 | 16 | +----------------+-------+-------+--------+------+-------+ | range | 32-63 | 64-95 | 96-127 | 0-15 | 16-31 | +----------------+-------+-------+--------+------+-------+
The next state is determined from the current state by reading the required Number_of_Bits, and adding the specified Baseline.
See Appendix B for the results of this process applied to the default distributions.
Zstandard Huffman-coded streams are read backwards, similar to the FSE bitstreams. Therefore, to find the start of the bitstream, it is necessary to know the offset of the last byte of the Huffman-coded stream.
After writing the last bit containing information, the compressor writes a single 1-bit and then fills the byte with 0-7 0 bits of padding. The last byte of the compressed bitstream cannot be 0 for that reason.
When decompressing, the last byte containing the padding is the first byte to read. The decompressor needs to skip 0-7 initial 0-bits and the first 1-bit lt occurs. Afterwards, the useful part of the bitstream begins.
The bitstream contains Huffman-coded symbols in little-endian order, with the codes defined by the method below.
Prefix coding represents symbols from an a priori known alphabet by bit sequences (codewords), one codeword for each symbol, in a manner such that different symbols may be represented by bit sequences of different lengths, but a parser can always parse an encoded string unambiguously symbol-by-symbol.
Given an alphabet with known symbol frequencies, the Huffman algorithm allows the construction of an optimal prefix code using the fewest bits of any possible prefix codes for that alphabet.
The prefix code must not exceed a maximum code length. More bits improve accuracy but yield a larger header size, and require more memory or more complex decoding operations. This specification limits the maximum code length to 11 bits.
if Weight == 0
Number_of_Bits = 0
else
Number_of_Bits = Max_Number_of_Bits + 1 - Weight
All literal values from zero (included) to the last present one (excluded) are represented by Weight with values from 0 to Max_Number_of_Bits. Transformation from Weight to Number_of_Bits follows this pseudocode:
The last symbol's Weight is deduced from previously decoded ones, by completing to the nearest power of 2. This power of 2 gives Max_Number_of_Bits, the depth of the current tree.
+----------------+---------+ | Number_of_Bits | literal | +----------------+---------+ | 1 | 0 | +----------------+---------+ | 2 | 1 | +----------------+---------+ | 3 | 2 | +----------------+---------+ | 0 | 3 | +----------------+---------+ | 4 | 4 | +----------------+---------+ | 4 | 5 | +----------------+---------+
For example, presume the following Huffman tree must be described:
if Number_of_Bits == 0
Weight = 0
else
Weight = Max_Number_of_Bits + 1 - Number_of_Bits
The tree depth is 4, since its smallest element uses 4 bits. Value 5 will not be listed as it can be determined from the values for 0-4, nor will values above 5 as they are all 0. Values from 0 to 4 will be listed using Weight instead of Number_of_Bits. The pseudocode to determine Weight is:
+---------+--------+ | literal | Weight | +---------+--------+ | 0 | 4 | +---------+--------+ | 1 | 3 | +---------+--------+ | 2 | 2 | +---------+--------+ | 3 | 0 | +---------+--------+ | 4 | 1 | +---------+--------+
It gives the following series of weights:
The decoder will do the inverse operation: having collected weights of literals from 0 to 4, it knows the last literal, 5, is present with a non-zero weight. The weight of 5 can be determined by advancing to the next power of 2. The sum of 2^(Weight-1) (excluding 0's) is 15. The nearest power of 2 is 16. Therefore, Max_Number_of_Bits = 4 and Weight[5] = 1.
Weight[0] = (Byte[0] >> 4) Weight[1] = (Byte[0] & 0xf), etc.
This is a single byte value (0-255), which describes how to decode the list of weights.
In this case, the series of Huffman weights is compressed using FSE compression. It is a single bitstream with two interleaved states, sharing a single distribution table.
To decode an FSE bitstream, it is necessary to know its compressed size. Compressed size is provided by headerByte. It's also necessary to know its maximum possible decompressed size, which is 255, since literal values span from 0 to 255, and the last symbol's weight is not represented.
An FSE bitstream starts by a header, describing probabilities distribution. It will create a Decoding Table. For a list of Huffman weights, the maximum accuracy log is 7 bits. For more description see Section 2.4.1.1.
The Huffman header compression uses two states, which share the same FSE distribution table. The first state (State1) encodes the even indexed symbols, and the second (State2) encodes the odd indexes. State1 is initialized first, and then State2, and they take turns decoding a single symbol and updating their state. For more details on these FSE operations, see the FSE section.
The number of symbols to decode is determined by tracking the bitStream overflow condition: If updating state after decoding a symbol would require more bits than remain in the stream, it is assumed that extra bits are zero. Then, the symbols for each of the I final states are decoded and the process is complete.
if Number_of_Bits != 0
Number_of_Bits = Max_Number_of_Bits + 1 - Weight
All present symbols will now have a Weight value. It is possible to transform weights into Number_of_Bits, using this formula:
Symbols are sorted by Weight. Within same Weight, symbols keep natural order. Symbols with a Weight of zero are removed. Then, starting from lowest weight, prefix codes are distributed in order.
+---------+--------+ | Literal | Weight | +---------+--------+ | 0 | 4 | +---------+--------+ | 1 | 3 | +---------+--------+ | 2 | 2 | +---------+--------+ | 3 | 0 | +---------+--------+ | 4 | 1 | +---------+--------+ | 5 | 1 | +---------+--------+
For example, assume the following list of weights has been decoded:
+---------+--------+----------------+--------------+ | Literal | Weight | Number_Of_Bits | prefix codes | +---------+--------+----------------|--------------+ | 3 | 0 | 0 | N/A | +---------+--------+----------------|--------------+ | 4 | 1 | 4 | 0000 | +---------+--------+----------------|--------------+ | 5 | 1 | 4 | 0001 | +---------+--------+----------------|--------------+ | 2 | 2 | 3 | 001 | +---------+--------+----------------|--------------+ | 1 | 3 | 2 | 01 | +---------+--------+----------------|--------------+ | 0 | 4 | 1 | 1 | +---------+--------+----------------|--------------+
Sorted by weight and then the natural order, yielding the following distribution:
Given a Huffman decoding table, it is possible to decode a Huffman-coded stream.
Each bitstream must be read backward, that is starting from the end up to the beginning. Therefore, it is necessary to know the size of each bitstream.
It is also necessary to know exactly which bit is the latest. This is detected by a final bit flag: the highest bit of latest byte is a final-bit-flag. Consequently, a last byte of 0 is not possible. And the final-bit-flag itself is not part of the useful bitstream. Hence, the last byte contains between 0 and 7 useful bits.
Starting from the end, it is possible to read the bitstream in a little-endian fashion, keeping track of already used bits. Since the bitstream is encoded in reverse order, starting from the end, read symbols in forward order.
+---------+----------+ | Symbol | Encoding | +---------+----------+ | 5 | 0000 | +---------+----------+ | 4 | 0001 | +---------+----------+ | 1 | 01 | +---------+----------+ | 0 | 1 | +---------+----------+ | Padding | 00001 | +---------+----------+
For example, if the literal sequence "0145" was encoded using above prefix code, it would be encoded (in reverse order) as:
00010000 00001101
This results in the following two-byte bitstream:
0001_0000 00001_1_01
Here is an alternative representation with the symbol codes separated by underscores:
Reading the highest Max_Number_of_Bits bits, it's possible to compare the extracted value to the decoding table, determining the symbol to decode and number of bits to discard.
The process continues up to reading the required number of symbols per stream. If a bitstream is not entirely and exactly consumed, hence reaching exactly its beginning position with all bits consumed, the decoding process is considered faulty.
Zstandard is compatible with "raw content" dictionaries, free of any format restriction, except that they must be at least eight bytes. These dictionaries function as if they were just the Content part of a formatted dictionary.
However, dictionaries created by "zstd --train" in the reference implementation follow a specific format, described here.
+--------------+---------------+----------------+---------+ | Magic_Number | Dictionary_ID | Entropy_Tables | Content | +--------------+---------------+----------------+---------+
A dictionary has a size, defined either by a buffer limit or a file size. The general format is:
- low range : <= 32767 - high range : >= (2^31)
This document contains two registration actions for IANA.
The 'application/zstd' media type identifies a block of data that is compressed using zstd compression. The data is a stream of bytes as described in this document. IANA is requested to add the following to the Media Types registry:
IANA is requested to add the following entry to the HTTP Content Coding Parameters subregistry within the Hypertext Transfer Protocol (HTTP) registry:
Any data compression method involves the reduction of redundancy in the data. Zstandard is no exception, and the usual precautions apply.
One should never compress together a message whose content must remain secret with a message under control of a third party. This can be used to guess the content of the secret message through analysis of entropy reduction. This was demonstrated in the [CRIME] attack for example.
A decoder has to demonstrate capabilities to detect and prevent any kind of data tampering in the compressed frame from triggering system faults, such as reading or writing beyond allowed memory ranges. This can be guaranteed either by the implementation language, or by careful bound checkings. It is highly recommended to fuzz-test decoder implementations to test and harden their capability to detect bad frames and deal with them without any system side-effect.
An attacker may provide correctly formed compressed frames with unreasonable memory requirements. A decoder must always control memory requirements and enforce some (system-specific) limits in order to protect memory usage from such scenarios.
[RFC EDITOR: Please remove this section prior to publication.]
Source code for a C language implementation of a "Zstandard" compliant library is available at [ZSTD-GITHUB]. This implementation is production ready, implementing the full range of the specification. It is tested against security hazards, and widely deployed within Facebook infrastructure.
The reference version is speed optimised and highly portable. It has been proven to run safely on multiple architectures (x86, x64, ARM, MIPS, PowerPC, IA64) featuring 32 or 64-bits addressing schemes, little or big endian storage scheme, a number of different operating systems, UNIX (including Linux, BSD, OS-X and Solaris), and Windows, and a number of compilers (gcc, clang, visual, icc).
The C reference version is also used to bind into multiple languages, a partial list of which (~20 of them) is being maintained at [ZSTD-OTHER].
The reference repository also contains an independently developed educational decoder, by Sean Purcell, created from the Zstandard format specification and built for clarity to help third party implementers. This is available at [ZSTD-EDU].
A specific version has been created for integration into the Linux kernel in order to provide compatibility with relevant memory restrictions. It was released in version 4.14 of the kernel. See [ZSTD-LINUX].
A Java native implementation of the decoder has been developed and open-sourced by the Presto team. This is available at [ZSTD-JAVA].
As of early July 2017, we are aware of one other decoder implementation in assembler, two full codec hardware implementations (programmable and ASIC) being actively developed, and a third one being evaluated. We are not permitted to disclose them at this stage.
| [ZSTD] | "Zstandard - Real-time data compression algorithm", 2017. |
| [ANS] | "Asymmetric Numeral Systems: Entropy Coding Combining Speed of Huffman Coding with Compression Rate of Arithmetic Coding", 2017. |
| [CRIME] | "Compression Ratio Info-leak Made Easy", 2017. |
| [FSE] | "Finite State Entropy", 2017. |
| [LZ4] | "LZ4 Frame Format Description", 2017. |
| [RFC1952] | Deutsch, P., "GZIP file format specification version 4.3", RFC 1952, DOI 10.17487/RFC1952, May 1996. |
| [XXHASH] | "XXHASH Algorithm", 2017. |
| [ZSTD-EDU] | "Zstandard Educational Decoder", 2017. |
| [ZSTD-GITHUB] | "Zstandard Github Repository", 2017. |
| [ZSTD-JAVA] | "Zstandard Github Repository", 2017. |
| [ZSTD-LINUX] | "Zstandard Github Repository", 2017. |
| [ZSTD-OTHER] | "Zstandard Language Bindings", 2017. |
zstd was developed by Yann Collet.
This appendix contains FSE decoding tables for the predefined literal length, match length, and offset codes. The tables have been constructed using the algorithm as given above in chapter "from normalized distribution to decoding tables". The tables here can be used as examples to crosscheck that an implementation build its decoding tables correctly.
+-------+--------+----------------+------+ | State | Symbol | Number_Of_Bits | Base | +-------+--------+----------------+------+ | 0 | 0 | 0 | 0 | +-------+--------+----------------+------+ | 0 | 0 | 4 | 0 | +-------+--------+----------------+------+ | 1 | 0 | 4 | 16 | +-------+--------+----------------+------+ | 2 | 1 | 5 | 32 | +-------+--------+----------------+------+ | 3 | 3 | 5 | 0 | +-------+--------+----------------+------+ | 4 | 4 | 5 | 0 | +-------+--------+----------------+------+ | 5 | 6 | 5 | 0 | +-------+--------+----------------+------+ | 6 | 7 | 5 | 0 | +-------+--------+----------------+------+ | 7 | 9 | 5 | 0 | +-------+--------+----------------+------+ | 8 | 10 | 5 | 0 | +-------+--------+----------------+------+ | 9 | 12 | 5 | 0 | +-------+--------+----------------+------+ | 10 | 14 | 6 | 0 | +-------+--------+----------------+------+ | 11 | 16 | 5 | 0 | +-------+--------+----------------+------+ | 12 | 18 | 5 | 0 | +-------+--------+----------------+------+ | 13 | 19 | 5 | 0 | +-------+--------+----------------+------+ | 14 | 21 | 5 | 0 | +-------+--------+----------------+------+ | 15 | 22 | 5 | 0 | +-------+--------+----------------+------+ | 16 | 24 | 5 | 0 | +-------+--------+----------------+------+ | 17 | 25 | 5 | 32 | +-------+--------+----------------+------+ | 18 | 26 | 5 | 0 | +-------+--------+----------------+------+ | 19 | 27 | 6 | 0 | +-------+--------+----------------+------+ | 20 | 29 | 6 | 0 | +-------+--------+----------------+------+ | 21 | 31 | 6 | 0 | +-------+--------+----------------+------+ | 22 | 0 | 4 | 32 | +-------+--------+----------------+------+ | 23 | 1 | 4 | 0 | +-------+--------+----------------+------+ | 24 | 2 | 5 | 0 | +-------+--------+----------------+------+ | 25 | 4 | 5 | 32 | +-------+--------+----------------+------+ | 26 | 5 | 5 | 0 | +-------+--------+----------------+------+ | 27 | 7 | 5 | 32 | +-------+--------+----------------+------+ | 28 | 8 | 5 | 0 | +-------+--------+----------------+------+ | 29 | 10 | 5 | 32 | +-------+--------+----------------+------+ | 30 | 11 | 5 | 0 | +-------+--------+----------------+------+ | 31 | 13 | 6 | 0 | +-------+--------+----------------+------+ | 32 | 16 | 5 | 32 | +-------+--------+----------------+------+ | 33 | 17 | 5 | 0 | +-------+--------+----------------+------+ | 34 | 19 | 5 | 32 | +-------+--------+----------------+------+ | 35 | 20 | 5 | 0 | +-------+--------+----------------+------+ | 36 | 22 | 5 | 32 | +-------+--------+----------------+------+ | 37 | 23 | 5 | 0 | +-------+--------+----------------+------+ | 38 | 25 | 4 | 0 | +-------+--------+----------------+------+ | 39 | 25 | 4 | 16 | +-------+--------+----------------+------+ | 40 | 26 | 5 | 32 | +-------+--------+----------------+------+ | 41 | 28 | 6 | 0 | +-------+--------+----------------+------+ | 42 | 30 | 6 | 0 | +-------+--------+----------------+------+ | 43 | 0 | 4 | 48 | +-------+--------+----------------+------+ | 44 | 1 | 4 | 16 | +-------+--------+----------------+------+ | 45 | 2 | 5 | 32 | +-------+--------+----------------+------+ | 46 | 3 | 5 | 32 | +-------+--------+----------------+------+ | 47 | 5 | 5 | 32 | +-------+--------+----------------+------+ | 48 | 6 | 5 | 32 | +-------+--------+----------------+------+ | 49 | 8 | 5 | 32 | +-------+--------+----------------+------+ | 50 | 9 | 5 | 32 | +-------+--------+----------------+------+ | 51 | 11 | 5 | 32 | +-------+--------+----------------+------+ | 52 | 12 | 5 | 32 | +-------+--------+----------------+------+ | 53 | 15 | 6 | 0 | +-------+--------+----------------+------+ | 54 | 17 | 5 | 32 | +-------+--------+----------------+------+ | 55 | 18 | 5 | 32 | +-------+--------+----------------+------+ | 56 | 20 | 5 | 32 | +-------+--------+----------------+------+ | 57 | 21 | 5 | 32 | +-------+--------+----------------+------+ | 58 | 23 | 5 | 32 | +-------+--------+----------------+------+ | 59 | 24 | 5 | 32 | +-------+--------+----------------+------+ | 60 | 35 | 6 | 0 | +-------+--------+----------------+------+ | 61 | 34 | 6 | 0 | +-------+--------+----------------+------+ | 62 | 33 | 6 | 0 | +-------+--------+----------------+------+ | 63 | 32 | 6 | 0 | +-------+--------+----------------+------+
+-------+--------+----------------+------+ | State | Symbol | Number_Of_Bits | Base | +-------+--------+----------------+------+ | 0 | 0 | 0 | 0 | +-------+--------+----------------+------+ | 0 | 0 | 6 | 0 | +-------+--------+----------------+------+ | 1 | 1 | 4 | 0 | +-------+--------+----------------+------+ | 2 | 2 | 5 | 32 | +-------+--------+----------------+------+ | 3 | 3 | 5 | 0 | +-------+--------+----------------+------+ | 4 | 5 | 5 | 0 | +-------+--------+----------------+------+ | 5 | 6 | 5 | 0 | +-------+--------+----------------+------+ | 6 | 8 | 5 | 0 | +-------+--------+----------------+------+ | 7 | 10 | 6 | 0 | +-------+--------+----------------+------+ | 8 | 13 | 6 | 0 | +-------+--------+----------------+------+ | 9 | 16 | 6 | 0 | +-------+--------+----------------+------+ | 10 | 19 | 6 | 0 | +-------+--------+----------------+------+ | 11 | 22 | 6 | 0 | +-------+--------+----------------+------+ | 12 | 25 | 6 | 0 | +-------+--------+----------------+------+ | 13 | 28 | 6 | 0 | +-------+--------+----------------+------+ | 14 | 31 | 6 | 0 | +-------+--------+----------------+------+ | 15 | 33 | 6 | 0 | +-------+--------+----------------+------+ | 16 | 35 | 6 | 0 | +-------+--------+----------------+------+ | 17 | 37 | 6 | 0 | +-------+--------+----------------+------+ | 18 | 39 | 6 | 0 | +-------+--------+----------------+------+ | 19 | 41 | 6 | 0 | +-------+--------+----------------+------+ | 20 | 43 | 6 | 0 | +-------+--------+----------------+------+ | 21 | 45 | 6 | 0 | +-------+--------+----------------+------+ | 22 | 1 | 4 | 16 | +-------+--------+----------------+------+ | 23 | 2 | 4 | 0 | +-------+--------+----------------+------+ | 24 | 3 | 5 | 32 | +-------+--------+----------------+------+ | 25 | 4 | 5 | 0 | +-------+--------+----------------+------+ | 26 | 6 | 5 | 32 | +-------+--------+----------------+------+ | 27 | 7 | 5 | 0 | +-------+--------+----------------+------+ | 28 | 9 | 6 | 0 | +-------+--------+----------------+------+ | 29 | 12 | 6 | 0 | +-------+--------+----------------+------+ | 30 | 15 | 6 | 0 | +-------+--------+----------------+------+ | 31 | 18 | 6 | 0 | +-------+--------+----------------+------+ | 32 | 21 | 6 | 0 | +-------+--------+----------------+------+ | 33 | 24 | 6 | 0 | +-------+--------+----------------+------+ | 34 | 27 | 6 | 0 | +-------+--------+----------------+------+ | 35 | 30 | 6 | 0 | +-------+--------+----------------+------+ | 36 | 32 | 6 | 0 | +-------+--------+----------------+------+ | 37 | 34 | 6 | 0 | +-------+--------+----------------+------+ | 38 | 36 | 6 | 0 | +-------+--------+----------------+------+ | 39 | 38 | 6 | 0 | +-------+--------+----------------+------+ | 40 | 40 | 6 | 0 | +-------+--------+----------------+------+ | 41 | 42 | 6 | 0 | +-------+--------+----------------+------+ | 42 | 44 | 6 | 0 | +-------+--------+----------------+------+ | 43 | 1 | 4 | 32 | +-------+--------+----------------+------+ | 44 | 1 | 4 | 48 | +-------+--------+----------------+------+ | 45 | 2 | 4 | 16 | +-------+--------+----------------+------+ | 46 | 4 | 5 | 32 | +-------+--------+----------------+------+ | 47 | 5 | 5 | 32 | +-------+--------+----------------+------+ | 48 | 7 | 5 | 32 | +-------+--------+----------------+------+ | 49 | 8 | 5 | 32 | +-------+--------+----------------+------+ | 50 | 11 | 6 | 0 | +-------+--------+----------------+------+ | 51 | 14 | 6 | 0 | +-------+--------+----------------+------+ | 52 | 17 | 6 | 0 | +-------+--------+----------------+------+ | 53 | 20 | 6 | 0 | +-------+--------+----------------+------+ | 54 | 23 | 6 | 0 | +-------+--------+----------------+------+ | 55 | 26 | 6 | 0 | +-------+--------+----------------+------+ | 56 | 29 | 6 | 0 | +-------+--------+----------------+------+ | 57 | 52 | 6 | 0 | +-------+--------+----------------+------+ | 58 | 51 | 6 | 0 | +-------+--------+----------------+------+ | 59 | 50 | 6 | 0 | +-------+--------+----------------+------+ | 60 | 49 | 6 | 0 | +-------+--------+----------------+------+ | 61 | 48 | 6 | 0 | +-------+--------+----------------+------+ | 62 | 47 | 6 | 0 | +-------+--------+----------------+------+ | 63 | 46 | 6 | 0 | +-------+--------+----------------+------+
+-------+--------+----------------+------+ | State | Symbol | Number_Of_Bits | Base | +-------+--------+----------------+------+ | 0 | 0 | 0 | 0 | +-------+--------+----------------+------+ | 0 | 0 | 5 | 0 | +-------+--------+----------------+------+ | 1 | 6 | 4 | 0 | +-------+--------+----------------+------+ | 2 | 9 | 5 | 0 | +-------+--------+----------------+------+ | 3 | 15 | 5 | 0 | +-------+--------+----------------+------+ | 4 | 21 | 5 | 0 | +-------+--------+----------------+------+ | 5 | 3 | 5 | 0 | +-------+--------+----------------+------+ | 6 | 7 | 4 | 0 | +-------+--------+----------------+------+ | 7 | 12 | 5 | 0 | +-------+--------+----------------+------+ | 8 | 18 | 5 | 0 | +-------+--------+----------------+------+ | 9 | 23 | 5 | 0 | +-------+--------+----------------+------+ | 10 | 5 | 5 | 0 | +-------+--------+----------------+------+ | 11 | 8 | 4 | 0 | +-------+--------+----------------+------+ | 12 | 14 | 5 | 0 | +-------+--------+----------------+------+ | 13 | 20 | 5 | 0 | +-------+--------+----------------+------+ | 14 | 2 | 5 | 0 | +-------+--------+----------------+------+ | 15 | 7 | 4 | 16 | +-------+--------+----------------+------+ | 16 | 11 | 5 | 0 | +-------+--------+----------------+------+ | 17 | 17 | 5 | 0 | +-------+--------+----------------+------+ | 18 | 22 | 5 | 0 | +-------+--------+----------------+------+ | 19 | 4 | 5 | 0 | +-------+--------+----------------+------+ | 20 | 8 | 4 | 16 | +-------+--------+----------------+------+ | 21 | 13 | 5 | 0 | +-------+--------+----------------+------+ | 22 | 19 | 5 | 0 | +-------+--------+----------------+------+ | 23 | 1 | 5 | 0 | +-------+--------+----------------+------+ | 24 | 6 | 4 | 16 | +-------+--------+----------------+------+ | 25 | 10 | 5 | 0 | +-------+--------+----------------+------+ | 26 | 16 | 5 | 0 | +-------+--------+----------------+------+ | 27 | 28 | 5 | 0 | +-------+--------+----------------+------+ | 28 | 27 | 5 | 0 | +-------+--------+----------------+------+ | 29 | 26 | 5 | 0 | +-------+--------+----------------+------+ | 30 | 25 | 5 | 0 | +-------+--------+----------------+------+ | 31 | 24 | 5 | 0 | +-------+--------+----------------+------+