RFC 8478
Zstandard Compression and the application/zstd Media Type
Internet Engineering Task Force (IETF) Y. Collet Request for Comments: 8478 M. Kucherawy, Ed. Category: Informational Facebook ISSN: 2070-1721 October 2018 Zstandard Compression and the application/zstd Media TypeAbstract
Zstandard, or "zstd" (pronounced "zee standard"), is a data compression mechanism. This document describes the mechanism and registers a media type and content encoding to be used when transporting zstd-compressed content via Multipurpose Internet Mail Extensions (MIME). Despite use of the word "standard" as part of its name, readers are advised that this document is not an Internet Standards Track specification; it is being published for informational purposes only. Status of This Memo This document is not an Internet Standards Track specification; it is published for informational purposes. This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Not all documents approved by the IESG are candidates for any level of Internet Standard; see Section 2 of RFC 7841. Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at https://www.rfc-editor.org/info/rfc8478.
Copyright Notice Copyright (c) 2018 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.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 4 2. Definitions . . . . . . . . . . . . . . . . . . . . . . . . . 4 3. Compression Algorithm . . . . . . . . . . . . . . . . . . . . 5 3.1. Frames . . . . . . . . . . . . . . . . . . . . . . . . . 6 3.1.1. Zstandard Frames . . . . . . . . . . . . . . . . . . 6 3.1.1.1. Frame Header . . . . . . . . . . . . . . . . . . 7 3.1.1.2. Blocks . . . . . . . . . . . . . . . . . . . . . 12 3.1.1.3. Compressed Blocks . . . . . . . . . . . . . . . . 14 3.1.1.4. Sequence Execution . . . . . . . . . . . . . . . 28 3.1.1.5. Repeat Offsets . . . . . . . . . . . . . . . . . 29 3.1.2. Skippable Frames . . . . . . . . . . . . . . . . . . 30 4. Entropy Encoding . . . . . . . . . . . . . . . . . . . . . . 30 4.1. FSE . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 4.1.1. FSE Table Description . . . . . . . . . . . . . . . . 31 4.2. Huffman Coding . . . . . . . . . . . . . . . . . . . . . 34 4.2.1. Huffman Tree Description . . . . . . . . . . . . . . 35 4.2.1.1. Huffman Tree Header . . . . . . . . . . . . . . . 36 4.2.1.2. FSE Compression of Huffman Weights . . . . . . . 37 4.2.1.3. Conversion from Weights to Huffman Prefix Codes . 38 4.2.2. Huffman-Coded Streams . . . . . . . . . . . . . . . . 39 5. Dictionary Format . . . . . . . . . . . . . . . . . . . . . . 40 6. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 42 6.1. The 'application/zstd' Media Type . . . . . . . . . . . . 42 6.2. Content Encoding . . . . . . . . . . . . . . . . . . . . 43 6.3. Dictionaries . . . . . . . . . . . . . . . . . . . . . . 43 7. Security Considerations . . . . . . . . . . . . . . . . . . . 43 8. Implementation Status . . . . . . . . . . . . . . . . . . . . 44 9. References . . . . . . . . . . . . . . . . . . . . . . . . . 45 9.1. Normative References . . . . . . . . . . . . . . . . . . 45 9.2. Informative References . . . . . . . . . . . . . . . . . 45 Appendix A. Decoding Tables for Predefined Codes . . . . . . . . 46 A.1. Literal Length Code Table . . . . . . . . . . . . . . . . 46 A.2. Match Length Code Table . . . . . . . . . . . . . . . . . 49 A.3. Offset Code Table . . . . . . . . . . . . . . . . . . . . 52 Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 53 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 54
1. Introduction
Zstandard, or "zstd" (pronounced "zee standard"), is a data compression mechanism, akin to gzip [RFC1952]. Despite use of the word "standard" as part of its name, readers are advised that this document is not an Internet Standards Track specification; it is being published for informational purposes only. 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).2. Definitions
Some terms used elsewhere in this document are defined here for clarity. uncompressed: Describes an arbitrary set of bytes in their original form, prior to being subjected to compression. compress, compression: The act of processing a set of bytes via the compression mechanism described here. compressed: Describes the result of passing a set of bytes through this mechanism. The original input has thus been compressed. decompress, decompression: The act of processing a set of bytes through the inverse of the compression mechanism described here, in an attempt to recover the original set of bytes prior to compression. decompressed: Describes the result of passing a set of bytes through the reverse of this mechanism. When this is successful, the decompressed payload and the uncompressed payload are indistinguishable. encode: The process of translating data from one form to another; this may include compression or it may refer to other translations done as part of this specification. decode: The reverse of "encode"; describes a process of reversing a prior encoding to recover the original content.
frame: Content compressed by Zstandard is transformed into a
Zstandard frame. Multiple frames can be appended into a single
file or stream. A frame is completely independent, has a defined
beginning and end, and has a set of parameters that tells the
decoder how to decompress it.
block: A frame encapsulates one or multiple blocks. Each block
contains arbitrary content, which is described by its header, and
has a guaranteed maximum content size that depends upon frame
parameters. Unlike frames, each block depends on previous blocks
for proper decoding. However, each block can be decompressed
without waiting for its successor, allowing streaming operations.
natural order: A sequence or ordering of objects or values that is
typical of that type of object or value. A set of unique
integers, for example, is in "natural order" if when progressing
from one element in the set or sequence to the next, there is
never a decrease in value.
The naming convention for identifiers within the specification is
Mixed_Case_With_Underscores. Identifiers inside square brackets
indicate that the identifier is optional in the presented context.
3. Compression Algorithm
This section describes the Zstandard algorithm.
The purpose of this document is to define a lossless compressed data
format that is a) independent of the CPU type, operating system, file
system, and character set and b) is suitable for file compression and
pipe and streaming compression, using the Zstandard algorithm. The
text of the specification assumes a basic background in programming
at the level of bits and other primitive data representations.
The data can be produced or consumed, even for an arbitrarily long
sequentially presented input data stream, using only an a priori
bounded amount of intermediate storage, and hence can be used in data
communications. The format uses the Zstandard compression method,
and an optional xxHash-64 checksum method [XXHASH], for detection of
data corruption.
The data format defined by this specification does not attempt to
allow random access to compressed data.
Unless otherwise indicated below, a compliant compressor must produce
data sets that conform to the specifications presented here.
However, it does not need to support all options.
A compliant decompressor must be able to decompress at least one working set of parameters that conforms to the specifications presented here. It may also ignore informative fields, such as the checksum. Whenever it does not support a parameter defined in the compressed stream, it must produce a non-ambiguous error code and associated error message explaining which parameter is unsupported. This specification is intended for use by implementers of software to compress data into Zstandard format and/or decompress data from Zstandard format. The Zstandard format is supported by an open source reference implementation, written in portable C, and available at [ZSTD].3.1. Frames
Zstandard compressed data is made up of one or more frames. Each frame is independent and can be decompressed independently 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 custom user metadata.3.1.1. Zstandard Frames
The structure of a single Zstandard frame is as follows: +--------------------+------------+ | Magic_Number | 4 bytes | +--------------------+------------+ | Frame_Header | 2-14 bytes | +--------------------+------------+ | Data_Block | n bytes | +--------------------+------------+ | [More Data_Blocks] | | +--------------------+------------+ | [Content_Checksum] | 0-4 bytes | +--------------------+------------+ Magic_Number: 4 bytes, little-endian format. Value: 0xFD2FB528. Frame_Header: 2 to 14 bytes, detailed in Section 3.1.1.1. Data_Block: Detailed in Section 3.1.1.2. This is where data appears.
Content_Checksum: An optional 32-bit checksum, only present if
Content_Checksum_Flag is set. The content checksum is the result
of the XXH64() hash function [XXHASH] digesting the original
(decoded) data as input, and a seed of zero. The low 4 bytes of
the checksum are stored in little-endian format.
The magic number was selected to be less probable to find at the
beginning of an arbitrary file. It avoids trivial patterns (0x00,
0xFF, repeated bytes, increasing bytes, etc.), contains byte values
outside of ASCII range, and doesn't map into UTF-8 space, all of
which reduce the likelihood of its appearance at the top of a text
file.
3.1.1.1. Frame Header
The frame header has a variable size, with a minimum of 2 bytes and
up to 14 bytes depending on optional parameters. The structure of
Frame_Header is as follows:
+-------------------------+-----------+
| Frame_Header_Descriptor | 1 byte |
+-------------------------+-----------+
| [Window_Descriptor] | 0-1 byte |
+-------------------------+-----------+
| [Dictionary_ID] | 0-4 bytes |
+-------------------------+-----------+
| [Frame_Content_Size] | 0-8 bytes |
+-------------------------+-----------+
3.1.1.1.1. Frame_Header_Descriptor
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. +------------+-------------------------+ | 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 | +------------+-------------------------+ In this table, bit 7 is the highest bit, while bit 0 is the lowest one.3.1.1.1.1.1. Frame_Content_Size_Flag This is a 2-bit flag (equivalent to Frame_Header_Descriptor right- shifted 6 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: +----------------+--------+---+---+---+ | Flag_Value | 0 | 1 | 2 | 3 | +----------------+--------+---+---+---+ | FCS_Field_Size | 0 or 1 | 2 | 4 | 8 | +----------------+--------+---+---+---+ When Flag_Value is 0, FCS_Field_Size depends on Single_Segment_Flag: If Single_Segment_Flag is set, FCS_Field_Size is 1. Otherwise, FCS_Field_Size is 0; Frame_Content_Size is not provided.
3.1.1.1.1.2. Single_Segment_Flag 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 larger 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.3.1.1.1.1.3. Unused Bit A decoder compliant with this specification version shall not interpret this bit. It might be used in a future version, to signal a property that is not mandatory to properly decode the frame. An encoder compliant with this specification must set this bit to zero.3.1.1.1.1.4. Reserved Bit 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.3.1.1.1.1.5. Content_Checksum_Flag If this flag is set, a 32-bit Content_Checksum will be present at the frame's end. See the description of Content_Checksum above.
3.1.1.1.1.6. Dictionary_ID_Flag This is a 2-bit flag (= Frame_Header_Descriptor & 0x3) indicating whether a dictionary ID is provided within the header. It also specifies the size of this field as DID_Field_Size: +----------------+---+---+---+---+ | Flag_Value | 0 | 1 | 2 | 3 | +----------------+---+---+---+---+ | DID_Field_Size | 0 | 1 | 2 | 4 | +----------------+---+---+---+---+3.1.1.1.2. Window Descriptor
This provides guarantees about the minimum memory buffer required to decompress a frame. This information is important for decoders to allocate enough memory. 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). +------------+----------+----------+ | Bit Number | 7-3 | 2-0 | +------------+----------+----------+ | Field Name | Exponent | Mantissa | +------------+----------+----------+ The minimum memory buffer size is called Window_Size. It is described by the following formulae: windowLog = 10 + Exponent; windowBase = 1 << windowLog; windowAdd = (windowBase / 8) * Mantissa; Window_Size = windowBase + windowAdd; The minimum Window_Size is 1 KB. The maximum Window_Size is (1<<41) + 7*(1<<38) bytes, which is 3.75 TB. In general, larger Window_Size values tend to improve the compression ratio, but at the cost of increased memory usage. 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 that requests a memory size beyond decoder's authorized range. For improved interoperability, it's recommended for decoders to support values of Window_Size up to 8 MB and for encoders not to generate frames requiring a Window_Size larger than 8 MB. It's merely a recommendation though, and decoders are free to support larger or lower limits, depending on local limitations.3.1.1.1.3. Dictionary_ID
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 know which dictionary to use. Dictionary_ID field size is provided by DID_Field_Size. DID_Field_Size is directly derived from the value of Dictionary_ID_Flag. One byte can represent an ID 0-255; 2 bytes can represent an ID 0-65535; 4 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 4-byte dictionary ID, even if it is less efficient. Within private environments, any dictionary ID can be used. However, for frames and dictionaries distributed in public space, Dictionary_ID must be attributed carefully. The following ranges are reserved for use only with dictionaries that have been registered with IANA (see Section 6.3): low range: <= 32767 high range: >= (1 << 31) Any other value for Dictionary_ID can be used by private arrangement between participants. Any payload presented for decompression that references an unregistered reserved dictionary ID results in an error.
3.1.1.1.4. Frame Content Size
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. +----------------+--------------+ | FCS Field Size | Range | +----------------+--------------+ | 0 | unknown | +----------------+--------------+ | 1 | 0 - 255 | +----------------+--------------+ | 2 | 256 - 65791 | +----------------+--------------+ | 4 | 0 - 2^32 - 1 | +----------------+--------------+ | 8 | 0 - 2^64 - 1 | +----------------+--------------+ 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.3.1.1.2. Blocks
After Magic_Number and Frame_Header, there are some number of blocks. Each frame must have at least 1 block, but there is no upper limit on the number of blocks per frame. The structure of a block is as follows: +--------------+---------------+ | Block_Header | Block_Content | +--------------+---------------+ | 3 bytes | n bytes | +--------------+---------------+
Block_Header uses 3 bytes, written using little-endian convention.
It contains three fields:
+------------+------------+------------+
| Last_Block | Block_Type | Block_Size |
+------------+------------+------------+
| bit 0 | bits 1-2 | bits 3-23 |
+------------+------------+------------+
3.1.1.2.1. Last_Block
The lowest bit (Last_Block) signals whether 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 3.1.1).
3.1.1.2.2. Block_Type
The next 2 bits represent the Block_Type. There are four block
types:
+-----------+------------------+
| Value | Block_Type |
+-----------+------------------+
| 0 | Raw_Block |
+-----------+------------------+
| 1 | RLE_Block |
+-----------+------------------+
| 2 | Compressed_Block |
+-----------+------------------+
| 3 | Reserved |
+-----------+------------------+
Raw_Block: This is an uncompressed block. Block_Content contains
Block_Size bytes.
RLE_Block: This is a single byte, repeated Block_Size times.
Block_Content consists of a single byte. On the decompression
side, this byte must be repeated Block_Size times.
Compressed_Block: This is a compressed block as described in
Section 3.1.1.3. Block_Size is the length of Block_Content,
namely the compressed data. The decompressed size is not known,
but its maximum possible value is guaranteed (see below).
Reserved: This is not a block. This value cannot be used with the
current specification. If such a value is present, it is
considered to be corrupt data.
3.1.1.2.3. Block_Size
The upper 21 bits of Block_Header represent the Block_Size. Block_Size is the size of the block excluding the header. A block can contain any number of bytes (even zero), up to Block_Maximum_Decompressed_Size, which is the smallest of: o Window_Size o 128 KB A Compressed_Block has the extra restriction that Block_Size is always strictly less than the decompressed size. If this condition cannot be respected, the block must be sent uncompressed instead (i.e., treated as a Raw_Block).3.1.1.3. Compressed Blocks
To decompress a compressed block, the compressed size must be provided from the Block_Size field within Block_Header. A compressed block consists of two sections: a Literals Section (Section 3.1.1.3.1) and a Sequences_Section (Section 3.1.1.3.2). The results of the two sections are then combined to produce the decompressed data in Sequence Execution (Section 3.1.1.4). To decode a compressed block, the following elements are necessary: o Previous decoded data, up to a distance of Window_Size, or the beginning of the Frame, whichever is smaller. Single_Segment_Flag will be set in the latter case. o List of "recent offsets" from the previous Compressed_Block. o The previous Huffman tree, required by Treeless_Literals_Block type. o Previous Finite State Entropy (FSE) decoding tables, required by Repeat_Mode, for each symbol type (literals lengths, match lengths, offsets). Note that decoding tables are not always from the previous Compressed_Block: o Every decoding table can come from a dictionary.
o The Huffman tree comes from the previous
Compressed_Literals_Block.
3.1.1.3.1. Literals_Section_Header
All literals are regrouped in the first part of the block. They can
be decoded first and then copied during Sequence Execution (see
Section 3.1.1.4), or they can be decoded on the flow during Sequence
Execution.
Literals can be stored uncompressed or compressed using Huffman
prefix codes. When compressed, an optional tree description can be
present, followed by 1 or 4 streams.
+----------------------------+
| Literals_Section_Header |
+----------------------------+
| [Huffman_Tree_Description] |
+----------------------------+
| [Jump_Table] |
+----------------------------+
| Stream_1 |
+----------------------------+
| [Stream_2] |
+----------------------------+
| [Stream_3] |
+----------------------------+
| [Stream_4] |
+----------------------------+
3.1.1.3.1.1. Literals_Section_Header
This field describes how literals are packed. It's a byte-aligned
variable-size bit field, ranging from 1 to 5 bytes, using little-
endian convention.
+---------------------+-----------+
| Literals_Block_Type | 2 bits |
+---------------------+-----------+
| Size_Format | 1-2 bits |
+---------------------+-----------+
| Regenerated_Size | 5-20 bits |
+---------------------+-----------+
| [Compressed_Size] | 0-18 bits |
+---------------------+-----------+
In this representation, bits at the top are the lowest bits.
The Literals_Block_Type field uses the two lowest bits of the first
byte, describing four different block types:
+---------------------------+-------+
| Literals_Block_Type | Value |
+---------------------------+-------+
| Raw_Literals_Block | 0 |
+---------------------------+-------+
| RLE_Literals_Block | 1 |
+---------------------------+-------+
| Compressed_Literals_Block | 2 |
+---------------------------+-------+
| Treeless_Literals_Block | 3 |
+---------------------------+-------+
Raw_Literals_Block: Literals are stored uncompressed.
Literals_Section_Content is Regenerated_Size.
RLE_Literals_Block: Literals consist of a single-byte value repeated
Regenerated_Size times. Literals_Section_Content is 1.
Compressed_Literals_Block: This is a standard Huffman-compressed
block, starting with a Huffman tree description. See details
below. Literals_Section_Content is Compressed_Size.
Treeless_Literals_Block: This is a Huffman-compressed block, using
the Huffman tree from the previous Compressed_Literals_Block, or a
dictionary if there is no previous Huffman-compressed literals
block. Huffman_Tree_Description will be skipped. Note that if
this mode is triggered without any previous Huffman-table in the
frame (or dictionary, per Section 5), it should be treated as data
corruption. Literals_Section_Content is Compressed_Size.
The Size_Format is divided into two families:
o For Raw_Literals_Block and RLE_Literals_Block, it's only necessary
to decode Regenerated_Size. There is no Compressed_Size field.
o For Compressed_Block and Treeless_Literals_Block, it's required to
decode both Compressed_Size and Regenerated_Size (the decompressed
size). It's also necessary to decode the number of streams (1 or
4).
For values spanning several bytes, the convention is little endian.
Size_Format for Raw_Literals_Block and RLE_Literals_Block uses 1 or 2
bits. Its value is (Literals_Section_Header[0]>>2) & 0x3.
Size_Format == 00 or 10: Size_Format uses 1 bit. Regenerated_Size
uses 5 bits (value 0-31). Literals_Section_Header uses 1 byte.
Regenerated_Size = Literal_Section_Header[0]>>3.
Size_Format == 01: Size_Format uses 2 bits. Regenerated_Size uses
12 bits (values 0-4095). Literals_Section_Header uses 2 bytes.
Regenerated_Size = (Literals_Section_Header[0]>>4) +
(Literals_Section_Header[1]<<4).
Size_Format == 11: Size_Format uses 2 bits. Regenerated_Size uses
20 bits (values 0-1048575). Literals_Section_Header uses 3 bytes.
Regenerated_Size = (Literals_Section_Header[0]>>4) +
(Literals_Section_Header[1]<<4) + (Literals_Section_Header[2]<<12)
Only Stream_1 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
always uses 2 bits.
Size_Format == 00: A single stream. Both Regenerated_Size and
Compressed_Size use 10 bits (values 0-1023).
Literals_Section_Header uses 3 bytes.
Size_Format == 01: 4 streams. Both Regenerated_Size and
Compressed_Size use 10 bits (values 0-1023).
Literals_Section_Header uses 3 bytes.
Size_Format == 10: 4 streams. Both Regenerated_Size and
Compressed_Size use 14 bits (values 0-16383).
Literals_Section_Header uses 4 bytes.
Size_Format == 11: 4 streams. Both Regenerated_Size and
Compressed_Size use 18 bits (values 0-262143).
Literals_Section_Header uses 5 bytes.
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.
3.1.1.3.1.2. Raw_Literals_Block
The data in Stream_1 is Regenerated_Size bytes long. It contains the
raw literals data to be used during Sequence Execution
(Section 3.1.1.3.2).
3.1.1.3.1.3. RLE_Literals_Block Stream_1 consists of a single byte that should be repeated Regenerated_Size times to generate the decoded literals.3.1.1.3.1.4. Compressed_Literals_Block and Treeless_Literals_Block Both of these modes contain Huffman-encoded data. For Treeless_Literals_Block, the Huffman table comes from the previously compressed literals block, or from a dictionary; see Section 5.3.1.1.3.1.5. Huffman_Tree_Description This section is only present when the Literals_Block_Type type is Compressed_Literals_Block (2). The format of Huffman_Tree_Description can be found in Section 4.2.1. The size of Huffman_Tree_Description is determined during the decoding process. It must be used to determine where streams begin. Total_Streams_Size = Compressed_Size - Huffman_Tree_Description_Size3.1.1.3.1.6. Jump_Table The Jump_Table is only present when there are 4 Huffman-coded streams. (Reminder: Huffman-compressed data consists of either 1 or 4 Huffman- coded streams.) If only 1 stream is present, it is a single bitstream occupying the entire remaining portion of the literals block, encoded as described within Section 4.2.2. If there are 4 streams, Literals_Section_Header only provides enough information to know the decompressed and compressed sizes of all 4 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 3 bytes smaller, to reach a total decompressed size as specified in Regenerated_Size. The compressed size of each stream is provided explicitly in the Jump_Table. The Jump_Table is 6 bytes long and consists of three 2-byte little-endian fields, describing the compressed sizes of the first 3 streams. Stream4_Size is computed from Total_Streams_Size minus sizes of other streams.
Stream4_Size = Total_Streams_Size - 6
- Stream1_Size - Stream2_Size
- Stream3_Size
Note that if Stream1_Size + Stream2_Size + Stream3_Size exceeds
Total_Streams_Size, the data are considered corrupted.
Each of these 4 bitstreams is then decoded independently as a
Huffman-Coded stream, as described in Section 4.2.2.
3.1.1.3.2. Sequences_Section
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
literals section, these bytes are added at the end of the block.
This is described in more detail in Section 3.1.1.4.
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 the size of the Literals_Section:
Sequences_Section_Size = Block_Size - Literals_Section_Header -
Literals_Section_Content
3.1.1.3.2.1. Sequences_Section_Header This header consists of two items: o Number_of_Sequences o Symbol_Compression_Modes Number_of_Sequences is a variable size field using between 1 and 3 bytes. If the first byte is "byte0": o if (byte0 == 0): there are no sequences. The sequence section stops here. Decompressed content is defined entirely as Literals Section content. The FSE tables used in Repeat_Mode are not updated. o if (byte0 < 128): Number_of_Sequences = byte0. Uses 1 byte. o if (byte0 < 255): Number_of_Sequences = ((byte0 - 128) << 8) + byte1. Uses 2 bytes. o if (byte0 == 255): Number_of_Sequences = byte1 + (byte2 << 8) + 0x7F00. Uses 3 bytes. Symbol_Compression_Modes is a single byte, defining the compression mode of each symbol type. +-------------+----------------------+ | Bit Number | Field Name | +-------------+----------------------+ | 7-6 | Literal_Lengths_Mode | +-------------+----------------------+ | 5-4 | Offsets_Mode | +-------------+----------------------+ | 3-2 | Match_Lengths_Mode | +-------------+----------------------+ | 1-0 | Reserved | +-------------+----------------------+ The last field, Reserved, must be all zeroes.
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:
+-------+---------------------+
| Value | Compression_Mode |
+-------+---------------------+
| 0 | Predefined_Mode |
+-------+---------------------+
| 1 | RLE_Mode |
+-------+---------------------+
| 2 | FSE_Compressed_Mode |
+-------+---------------------+
| 3 | Repeat_Mode |
+-------+---------------------+
Predefined_Mode: A predefined FSE (see Section 4.1) distribution
table is used, as defined in Section 3.1.1.3.2.2. No distribution
table will be present.
RLE_Mode: The table description consists of a single byte, which
contains the symbol's value. This symbol will be used for all
sequences.
FSE_Compressed_Mode: Standard FSE compression. A distribution table
will be present. The format of this distribution table is
described in Section 4.1.1. Note that the maximum allowed
accuracy log for literals length and match length tables is 9, and
the maximum accuracy log for the offsets table is 8. This mode
must not be used when only one symbol is present; RLE_Mode should
be used instead (although any other mode will work).
Repeat_Mode: The table used in the previous Compressed_Block with
Number_Of_Sequences > 0 will be used again, or if this is the
first block, the table in the dictionary will be used. Note that
this includes RLE_Mode, so if Repeat_Mode follows RLE_Mode, the
same symbol will be repeated. It also includes Predefined_Mode,
in which case Repeat_Mode will have the same outcome as
Predefined_Mode. No distribution table will be present. If this
mode is used without any previous sequence table in the frame (or
dictionary; see Section 5) to repeat, this should be treated as
corruption.
3.1.1.3.2.1.1. Sequence Codes for Lengths and Offsets 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 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.
+----------------------+----------+----------------+
| 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 |
+----------------------+----------+----------------+
Match length codes are values ranging from 0 to 52 inclusive. 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.
+-------------------+-----------------------+----------------+
| Match_Length_Code | Baseline | Number_of_Bits |
+-------------------+-----------------------+----------------+
| 0-31 | Match_Length_Code + 3 | 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 |
+-------------------+-----------------------+----------------+
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 31.
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:
Offset_Value = (1 << offsetCode) + readNBits(offsetCode);
if (Offset_Value > 3) Offset = Offset_Value - 3;
This means that maximum Offset_Value is (2^(N+1))-1, supporting back-
reference distance up to (2^(N+1))-4, but it is limited by the
maximum back-reference distance (see Section 3.1.1.1.2).
Offset_Value from 1 to 3 are special: they define "repeat codes".
This is described in more detail in Section 3.1.1.5.
3.1.1.3.2.1.2. Decoding Sequences
FSE bitstreams are read in reverse of the direction they are 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 1 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 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 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 1 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 can be found in Section 3.1.1.3.2.1. Decoding starts by reading the Number_of_Bits required to decode offset. It does the same for Match_Length and then for Literals_Length. This sequence is then used for Sequence Execution (see Section 3.1.1.4). 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 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.3.1.1.3.2.2. Default Distributions 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 4.1.
3.1.1.3.2.2.1. Literals Length The decoding table uses an accuracy log of 6 bits (64 states). 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 }; 3.1.1.3.2.2.2. Match Length 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 }; 3.1.1.3.2.2.3. Offset Codes 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. 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. 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 };3.1.1.4. Sequence Execution
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 3.1.1.3.2). To execute a sequence, first copy literals_length bytes from the decoded literals to the output.
Then, match_length bytes are copied from previous decoded data. The
offset to copy from is determined by offset_value:
o if Offset_Value > 3, then the offset is Offset_Value - 3;
o if Offset_Value is from 1-3, the offset is a special repeat offset
value. See Section 3.1.1.5 for how the offset is determined in
this case.
The offset is defined as from the current position (after copying the
literals), 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 3.1.1.1.1).
3.1.1.5. Repeat Offsets
As seen above, the first three values define a repeated offset; 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 1, 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: Repeated_Offset1 (1), Repeated_Offset2 (4), and
Repeated_Offset3 (8), unless a dictionary is used, in which case they
come from the dictionary.
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 1.
3.1.2. Skippable Frames
+--------------+------------+-----------+ | Magic_Number | Frame_Size | User_Data | +--------------+------------+-----------+ | 4 bytes | 4 bytes | n bytes | +--------------+------------+-----------+ Skippable frames allow the insertion of user-defined metadata into a flow of concatenated frames. Skippable frames defined in this specification are compatible with skippable frames in [LZ4]. From a compliant decoder perspective, skippable frames simply need to be skipped, and their content ignored, resuming decoding after the skippable frame. It should be noted that a skippable frame can be used to watermark a stream of concatenated frames embedding any kind of tracking information (even just a Universally Unique Identifier (UUID)). Users wary of such possibility should scan the stream of concatenated frames in an attempt to detect such frames for analysis or removal. The fields are: Magic_Number: 4 bytes, little-endian format. Value: 0x184D2A5?, which means any value from 0x184D2A50 to 0x184D2A5F. All 16 values are valid to identify a skippable frame. This specification does not detail any specific tagging methods for skippable frames. Frame_Size: This is the size, in bytes, of the following User_Data (without including the magic number nor the size field itself). This field is represented using 4 bytes, little-endian format, unsigned 32 bits. This means User_Data can't be bigger than (2^32-1) bytes. User_Data: This field can be anything. Data will just be skipped by the decoder.
(page 30 continued on part 2)
