compress: Index | Files | Directories

package zstd

import ""

Package zstd provides decompression of zstandard files.

For advanced usage and examples, go to the README:


Package Files

bitreader.go bitwriter.go blockdec.go blockenc.go blocktype_string.go bytebuf.go bytereader.go decoder.go decoder_options.go dict.go enc_better.go enc_dfast.go enc_fast.go enc_params.go encoder.go encoder_options.go framedec.go frameenc.go fse_decoder.go fse_encoder.go fse_predefined.go hash.go history.go seqdec.go seqenc.go snappy.go zstd.go


const (
    // The minimum Window_Size is 1 KB.
    MinWindowSize = 1 << 10
    MaxWindowSize = 1 << 29


var (
    // ErrSnappyCorrupt reports that the input is invalid.
    ErrSnappyCorrupt = errors.New("snappy: corrupt input")
    // ErrSnappyTooLarge reports that the uncompressed length is too large.
    ErrSnappyTooLarge = errors.New("snappy: decoded block is too large")
    // ErrSnappyUnsupported reports that the input isn't supported.
    ErrSnappyUnsupported = errors.New("snappy: unsupported input")
var (
    // ErrReservedBlockType is returned when a reserved block type is found.
    // Typically this indicates wrong or corrupted input.
    ErrReservedBlockType = errors.New("invalid input: reserved block type encountered")

    // ErrCompressedSizeTooBig is returned when a block is bigger than allowed.
    // Typically this indicates wrong or corrupted input.
    ErrCompressedSizeTooBig = errors.New("invalid input: compressed size too big")

    // ErrBlockTooSmall is returned when a block is too small to be decoded.
    // Typically returned on invalid input.
    ErrBlockTooSmall = errors.New("block too small")

    // ErrMagicMismatch is returned when a "magic" number isn't what is expected.
    // Typically this indicates wrong or corrupted input.
    ErrMagicMismatch = errors.New("invalid input: magic number mismatch")

    // ErrWindowSizeExceeded is returned when a reference exceeds the valid window size.
    // Typically this indicates wrong or corrupted input.
    ErrWindowSizeExceeded = errors.New("window size exceeded")

    // ErrWindowSizeTooSmall is returned when no window size is specified.
    // Typically this indicates wrong or corrupted input.
    ErrWindowSizeTooSmall = errors.New("invalid input: window size was too small")

    // ErrDecoderSizeExceeded is returned if decompressed size exceeds the configured limit.
    ErrDecoderSizeExceeded = errors.New("decompressed size exceeds configured limit")

    // ErrUnknownDictionary is returned if the dictionary ID is unknown.
    // For the time being dictionaries are not supported.
    ErrUnknownDictionary = errors.New("unknown dictionary")

    // ErrFrameSizeExceeded is returned if the stated frame size is exceeded.
    // This is only returned if SingleSegment is specified on the frame.
    ErrFrameSizeExceeded = errors.New("frame size exceeded")

    // ErrCRCMismatch is returned if CRC mismatches.
    ErrCRCMismatch = errors.New("CRC check failed")

    // ErrDecoderClosed will be returned if the Decoder was used after
    // Close has been called.
    ErrDecoderClosed = errors.New("decoder used after Close")

type DOption Uses

type DOption func(*decoderOptions) error

DOption is an option for creating a decoder.

func WithDecoderConcurrency Uses

func WithDecoderConcurrency(n int) DOption

WithDecoderConcurrency will set the concurrency, meaning the maximum number of decoders to run concurrently. The value supplied must be at least 1. By default this will be set to GOMAXPROCS.

func WithDecoderDicts Uses

func WithDecoderDicts(dicts ...[]byte) DOption

WithDecoderDicts allows to register one or more dictionaries for the decoder. If several dictionaries with the same ID is provided the last one will be used.

func WithDecoderLowmem Uses

func WithDecoderLowmem(b bool) DOption

WithDecoderLowmem will set whether to use a lower amount of memory, but possibly have to allocate more while running.

func WithDecoderMaxMemory Uses

func WithDecoderMaxMemory(n uint64) DOption

WithDecoderMaxMemory allows to set a maximum decoded size for in-memory non-streaming operations or maximum window size for streaming operations. This can be used to control memory usage of potentially hostile content. For streaming operations, the maximum window size is capped at 1<<30 bytes. Maximum and default is 1 << 63 bytes.

type Decoder Uses

type Decoder struct {
    // contains filtered or unexported fields

Decoder provides decoding of zstandard streams. The decoder has been designed to operate without allocations after a warmup. This means that you should store the decoder for best performance. To re-use a stream decoder, use the Reset(r io.Reader) error to switch to another stream. A decoder can safely be re-used even if the previous stream failed. To release the resources, you must call the Close() function on a decoder.

func NewReader Uses

func NewReader(r io.Reader, opts ...DOption) (*Decoder, error)

NewReader creates a new decoder. A nil Reader can be provided in which case Reset can be used to start a decode.

A Decoder can be used in two modes:

1) As a stream, or 2) For stateless decoding using DecodeAll.

Only a single stream can be decoded concurrently, but the same decoder can run multiple concurrent stateless decodes. It is even possible to use stateless decodes while a stream is being decoded.

The Reset function can be used to initiate a new stream, which is will considerably reduce the allocations normally caused by NewReader.

func (*Decoder) Close Uses

func (d *Decoder) Close()

Close will release all resources. It is NOT possible to reuse the decoder after this.

func (*Decoder) DecodeAll Uses

func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error)

DecodeAll allows stateless decoding of a blob of bytes. Output will be appended to dst, so if the destination size is known you can pre-allocate the destination slice to avoid allocations. DecodeAll can be used concurrently. The Decoder concurrency limits will be respected.

func (*Decoder) IOReadCloser Uses

func (d *Decoder) IOReadCloser() io.ReadCloser

IOReadCloser returns the decoder as an io.ReadCloser for convenience. Any changes to the decoder will be reflected, so the returned ReadCloser can be reused along with the decoder. io.WriterTo is also supported by the returned ReadCloser.

func (*Decoder) Read Uses

func (d *Decoder) Read(p []byte) (int, error)

Read bytes from the decompressed stream into p. Returns the number of bytes written and any error that occurred. When the stream is done, io.EOF will be returned.

func (*Decoder) Reset Uses

func (d *Decoder) Reset(r io.Reader) error

Reset will reset the decoder the supplied stream after the current has finished processing. Note that this functionality cannot be used after Close has been called.

func (*Decoder) WriteTo Uses

func (d *Decoder) WriteTo(w io.Writer) (int64, error)

WriteTo writes data to w until there's no more data to write or when an error occurs. The return value n is the number of bytes written. Any error encountered during the write is also returned.

type EOption Uses

type EOption func(*encoderOptions) error

EOption is an option for creating a encoder.

func WithAllLitEntropyCompression Uses

func WithAllLitEntropyCompression(b bool) EOption

WithAllLitEntropyCompression will apply entropy compression if no matches are found. Disabling this will skip incompressible data faster, but in cases with no matches but skewed character distribution compression is lost. Default value depends on the compression level selected.

func WithEncoderCRC Uses

func WithEncoderCRC(b bool) EOption

WithEncoderCRC will add CRC value to output. Output will be 4 bytes larger.

func WithEncoderConcurrency Uses

func WithEncoderConcurrency(n int) EOption

WithEncoderConcurrency will set the concurrency, meaning the maximum number of decoders to run concurrently. The value supplied must be at least 1. By default this will be set to GOMAXPROCS.

func WithEncoderLevel Uses

func WithEncoderLevel(l EncoderLevel) EOption

WithEncoderLevel specifies a predefined compression level.

func WithEncoderPadding Uses

func WithEncoderPadding(n int) EOption

WithEncoderPadding will add padding to all output so the size will be a multiple of n. This can be used to obfuscate the exact output size or make blocks of a certain size. The contents will be a skippable frame, so it will be invisible by the decoder. n must be > 0 and <= 1GB, 1<<30 bytes. The padded area will be filled with data from crypto/rand.Reader. If `EncodeAll` is used with data already in the destination, the total size will be multiple of this.

func WithNoEntropyCompression Uses

func WithNoEntropyCompression(b bool) EOption

WithNoEntropyCompression will always skip entropy compression of literals. This can be useful if content has matches, but unlikely to benefit from entropy compression. Usually the slight speed improvement is not worth enabling this.

func WithSingleSegment Uses

func WithSingleSegment(b bool) EOption

WithSingleSegment will set the "single segment" flag when EncodeAll is used. 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 size of your content. In order to preserve the decoder from unreasonable memory requirements, a decoder is allowed to reject a compressed frame which requests a memory size beyond 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. If this is not specified, block encodes will automatically choose this based on the input size. This setting has no effect on streamed encodes.

func WithWindowSize Uses

func WithWindowSize(n int) EOption

WithWindowSize will set the maximum allowed back-reference distance. The value must be a power of two between MinWindowSize and MaxWindowSize. A larger value will enable better compression but allocate more memory and, for above-default values, take considerably longer. The default value is determined by the compression level.

func WithZeroFrames Uses

func WithZeroFrames(b bool) EOption

WithZeroFrames will encode 0 length input as full frames. This can be needed for compatibility with zstandard usage, but is not needed for this package.

type Encoder Uses

type Encoder struct {
    // contains filtered or unexported fields

Encoder provides encoding to Zstandard. An Encoder can be used for either compressing a stream via the io.WriteCloser interface supported by the Encoder or as multiple independent tasks via the EncodeAll function. Smaller encodes are encouraged to use the EncodeAll function. Use NewWriter to create a new instance.

func NewWriter Uses

func NewWriter(w io.Writer, opts ...EOption) (*Encoder, error)

NewWriter will create a new Zstandard encoder. If the encoder will be used for encoding blocks a nil writer can be used.

func (*Encoder) Close Uses

func (e *Encoder) Close() error

Close will flush the final output and close the stream. The function will block until everything has been written. The Encoder can still be re-used after calling this.

func (*Encoder) EncodeAll Uses

func (e *Encoder) EncodeAll(src, dst []byte) []byte

EncodeAll will encode all input in src and append it to dst. This function can be called concurrently, but each call will only run on a single goroutine. If empty input is given, nothing is returned, unless WithZeroFrames is specified. Encoded blocks can be concatenated and the result will be the combined input stream. Data compressed with EncodeAll can be decoded with the Decoder, using either a stream or DecodeAll.

func (*Encoder) Flush Uses

func (e *Encoder) Flush() error

Flush will send the currently written data to output and block until everything has been written. This should only be used on rare occasions where pushing the currently queued data is critical.

func (*Encoder) ReadFrom Uses

func (e *Encoder) ReadFrom(r io.Reader) (n int64, err error)

ReadFrom reads data from r until EOF or error. The return value n is the number of bytes read. Any error except io.EOF encountered during the read is also returned.

The Copy function uses ReaderFrom if available.

func (*Encoder) Reset Uses

func (e *Encoder) Reset(w io.Writer)

Reset will re-initialize the writer and new writes will encode to the supplied writer as a new, independent stream.

func (*Encoder) Write Uses

func (e *Encoder) Write(p []byte) (n int, err error)

Write data to the encoder. Input data will be buffered and as the buffer fills up content will be compressed and written to the output. When done writing, use Close to flush the remaining output and write CRC if requested.

type EncoderLevel Uses

type EncoderLevel int

EncoderLevel predefines encoder compression levels. Only use the constants made available, since the actual mapping of these values are very likely to change and your compression could change unpredictably when upgrading the library.

const (

    // SpeedFastest will choose the fastest reasonable compression.
    // This is roughly equivalent to the fastest Zstandard mode.
    SpeedFastest EncoderLevel

    // SpeedDefault is the default "pretty fast" compression option.
    // This is roughly equivalent to the default Zstandard mode (level 3).

    // SpeedBetterCompression will yield better compression than the default.
    // Currently it is about zstd level 7-8 with ~ 2x-3x the default CPU usage.
    // By using this, notice that CPU usage may go up in the future.

    // SpeedBestCompression will choose the best available compression option.
    // For now this is not implemented.
    SpeedBestCompression = SpeedBetterCompression

func EncoderLevelFromString Uses

func EncoderLevelFromString(s string) (bool, EncoderLevel)

EncoderLevelFromString will convert a string representation of an encoding level back to a compression level. The compare is not case sensitive. If the string wasn't recognized, (false, SpeedDefault) will be returned.

func EncoderLevelFromZstd Uses

func EncoderLevelFromZstd(level int) EncoderLevel

EncoderLevelFromZstd will return an encoder level that closest matches the compression ratio of a specific zstd compression level. Many input values will provide the same compression level.

func (EncoderLevel) String Uses

func (e EncoderLevel) String() string

String provides a string representation of the compression level.

type SnappyConverter Uses

type SnappyConverter struct {
    // contains filtered or unexported fields

SnappyConverter can read SnappyConverter-compressed streams and convert them to zstd. Conversion is done by converting the stream directly from Snappy without intermediate full decoding. Therefore the compression ratio is much less than what can be done by a full decompression and compression, and a faulty Snappy stream may lead to a faulty Zstandard stream without any errors being generated. No CRC value is being generated and not all CRC values of the Snappy stream are checked. However, it provides really fast recompression of Snappy streams. The converter can be reused to avoid allocations, even after errors.

func (*SnappyConverter) Convert Uses

func (r *SnappyConverter) Convert(in io.Reader, w io.Writer) (int64, error)

Convert the Snappy stream supplied in 'in' and write the zStandard stream to 'w'. If any error is detected on the Snappy stream it is returned. The number of bytes written is returned.



Package zstd imports 21 packages (graph) and is imported by 66 packages. Updated 2020-06-20. Refresh now. Tools for package owners.