Documentation ¶
Overview ¶
Package zstd provides decompression of zstandard files.
For advanced usage and examples, go to the README: https://github.com/klauspost/compress/tree/master/zstd#zstd
Index ¶
- Constants
- Variables
- func BuildDict(o BuildDictOptions) ([]byte, error)
- func InspectDictionary(b []byte) (interface{ ... }, error)
- func ZipCompressor(opts ...EOption) func(w io.Writer) (io.WriteCloser, error)
- func ZipDecompressor(opts ...DOption) func(r io.Reader) io.ReadCloser
- type BuildDictOptions
- type DOption
- func IgnoreChecksum(b bool) DOption
- func WithDecodeAllCapLimit(b bool) DOption
- func WithDecodeBuffersBelow(size int) DOption
- func WithDecoderConcurrency(n int) DOption
- func WithDecoderDictRaw(id uint32, content []byte) DOption
- func WithDecoderDicts(dicts ...[]byte) DOption
- func WithDecoderLowmem(b bool) DOption
- func WithDecoderMaxMemory(n uint64) DOption
- func WithDecoderMaxWindow(size uint64) DOption
- type Decoder
- type EOption
- func WithAllLitEntropyCompression(b bool) EOption
- func WithEncoderCRC(b bool) EOption
- func WithEncoderConcurrency(n int) EOption
- func WithEncoderDict(dict []byte) EOption
- func WithEncoderDictRaw(id uint32, content []byte) EOption
- func WithEncoderLevel(l EncoderLevel) EOption
- func WithEncoderPadding(n int) EOption
- func WithLowerEncoderMem(b bool) EOption
- func WithNoEntropyCompression(b bool) EOption
- func WithSingleSegment(b bool) EOption
- func WithWindowSize(n int) EOption
- func WithZeroFrames(b bool) EOption
- type Encoder
- func (e *Encoder) Close() error
- func (e *Encoder) EncodeAll(src, dst []byte) []byte
- func (e *Encoder) Flush() error
- func (e *Encoder) MaxEncodedSize(size int) int
- func (e *Encoder) ReadFrom(r io.Reader) (n int64, err error)
- func (e *Encoder) Reset(w io.Writer)
- func (e *Encoder) ResetContentSize(w io.Writer, size int64)
- func (e *Encoder) Write(p []byte) (n int, err error)
- type EncoderLevel
- type Header
- type SnappyConverter
Examples ¶
Constants ¶
const ( // MinWindowSize is the minimum Window Size, which is 1 KB. MinWindowSize = 1 << 10 // MaxWindowSize is the maximum encoder window size // and the default decoder maximum window size. MaxWindowSize = 1 << 29 )
const HeaderMaxSize = 14 + 3
HeaderMaxSize is the maximum size of a Frame and Block Header. If less is sent to Header.Decode it *may* still contain enough information.
const ZipMethodPKWare = 20
ZipMethodPKWare is the original method number used by PKWARE to indicate Zstandard compression. Deprecated: This has been deprecated by PKWARE, use ZipMethodWinZip instead for compression. See https://pkware.cachefly.net/webdocs/APPNOTE/APPNOTE-6.3.9.TXT
const ZipMethodWinZip = 93
ZipMethodWinZip is the method for Zstandard compressed data inside Zip files for WinZip. See https://www.winzip.com/win/en/comp_info.html
Variables ¶
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") // ErrUnexpectedBlockSize is returned when a block has unexpected size. // Typically returned on invalid input. ErrUnexpectedBlockSize = errors.New("unexpected block size") // 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. 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") // ErrFrameSizeMismatch is returned if the stated frame size does not match the expected size. // This is only returned if SingleSegment is specified on the frame. ErrFrameSizeMismatch = errors.New("frame size does not match size on stream") // 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") // ErrEncoderClosed will be returned if the Encoder was used after // Close has been called. ErrEncoderClosed = errors.New("encoder used after Close") // ErrDecoderNilInput is returned when a nil Reader was provided // and an operation other than Reset/DecodeAll/Close was attempted. ErrDecoderNilInput = errors.New("nil input provided as reader") )
Functions ¶
func BuildDict ¶ added in v1.17.0
func BuildDict(o BuildDictOptions) ([]byte, error)
func InspectDictionary ¶ added in v1.16.0
func InspectDictionary(b []byte) (interface { ID() uint32 ContentSize() int Content() []byte Offsets() [3]int LitEncoder() *huff0.Scratch }, error)
InspectDictionary loads a zstd dictionary and provides functions to inspect the content.
func ZipCompressor ¶ added in v1.12.2
ZipCompressor returns a compressor that can be registered with zip libraries. The provided encoder options will be used on all encodes.
Example ¶
package main import ( "archive/zip" "bytes" "fmt" "io" "github.com/klauspost/compress/zstd" ) func main() { // Get zstandard de/compressors for zip. // These can be used by multiple readers and writers. compr := zstd.ZipCompressor(zstd.WithWindowSize(1<<20), zstd.WithEncoderCRC(false)) decomp := zstd.ZipDecompressor() // Try it out... var buf bytes.Buffer zw := zip.NewWriter(&buf) zw.RegisterCompressor(zstd.ZipMethodWinZip, compr) zw.RegisterCompressor(zstd.ZipMethodPKWare, compr) // Create 1MB data tmp := make([]byte, 1<<20) for i := range tmp { tmp[i] = byte(i) } w, err := zw.CreateHeader(&zip.FileHeader{ Name: "file1.txt", Method: zstd.ZipMethodWinZip, }) if err != nil { panic(err) } w.Write(tmp) // Another... w, err = zw.CreateHeader(&zip.FileHeader{ Name: "file2.txt", Method: zstd.ZipMethodPKWare, }) w.Write(tmp) zw.Close() zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len())) if err != nil { panic(err) } zr.RegisterDecompressor(zstd.ZipMethodWinZip, decomp) zr.RegisterDecompressor(zstd.ZipMethodPKWare, decomp) for _, file := range zr.File { rc, err := file.Open() if err != nil { panic(err) } b, err := io.ReadAll(rc) rc.Close() if bytes.Equal(b, tmp) { fmt.Println(file.Name, "ok") } else { fmt.Println(file.Name, "mismatch") } } }
Output: file1.txt ok file2.txt ok
func ZipDecompressor ¶ added in v1.12.2
func ZipDecompressor(opts ...DOption) func(r io.Reader) io.ReadCloser
ZipDecompressor returns a decompressor that can be registered with zip libraries. See ZipCompressor for example. Options can be specified. WithDecoderConcurrency(1) is forced, and by default a 128MB maximum decompression window is specified. The window size can be overridden if required.
Types ¶
type BuildDictOptions ¶ added in v1.17.0
type BuildDictOptions struct { // Dictionary ID. ID uint32 // Content to use to create dictionary tables. Contents [][]byte // History to use for all blocks. History []byte // Offsets to use. Offsets [3]int // CompatV155 will make the dictionary compatible with Zstd v1.5.5 and earlier. // See https://github.com/facebook/zstd/issues/3724 CompatV155 bool // Use the specified encoder level. // The dictionary will be built using the specified encoder level, // which will reflect speed and make the dictionary tailored for that level. // If not set SpeedBestCompression will be used. Level EncoderLevel // DebugOut will write stats and other details here if set. DebugOut io.Writer }
type DOption ¶
type DOption func(*decoderOptions) error
DOption is an option for creating a decoder.
func IgnoreChecksum ¶ added in v1.15.3
IgnoreChecksum allows to forcibly ignore checksum checking.
func WithDecodeAllCapLimit ¶ added in v1.15.10
WithDecodeAllCapLimit will limit DecodeAll to decoding cap(dst)-len(dst) bytes, or any size set in WithDecoderMaxMemory. This can be used to limit decoding to a specific maximum output size. Disabled by default.
func WithDecodeBuffersBelow ¶ added in v1.15.11
WithDecodeBuffersBelow will fully decode readers that have a `Bytes() []byte` and `Len() int` interface similar to bytes.Buffer. This typically uses less allocations but will have the full decompressed object in memory. Note that DecodeAllCapLimit will disable this, as well as giving a size of 0 or less. Default is 128KiB.
func WithDecoderConcurrency ¶
WithDecoderConcurrency sets the number of created decoders. When decoding block with DecodeAll, this will limit the number of possible concurrently running decodes. When decoding streams, this will limit the number of inflight blocks. When decoding streams and setting maximum to 1, no async decoding will be done. When a value of 0 is provided GOMAXPROCS will be used. By default this will be set to 4 or GOMAXPROCS, whatever is lower.
func WithDecoderDictRaw ¶ added in v1.15.15
WithDecoderDictRaw registers a dictionary that may be used by the decoder. The slice content can be arbitrary data.
func WithDecoderDicts ¶ added in v1.10.9
WithDecoderDicts allows to register one or more dictionaries for the decoder.
Each slice in dict must be in the dictionary format produced by "zstd --train" from the Zstandard reference implementation.
If several dictionaries with the same ID are provided, the last one will be used.
func WithDecoderLowmem ¶
WithDecoderLowmem will set whether to use a lower amount of memory, but possibly have to allocate more while running.
func WithDecoderMaxMemory ¶
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. Maximum is 1 << 63 bytes. Default is 64GiB.
func WithDecoderMaxWindow ¶ added in v1.13.1
WithDecoderMaxWindow allows to set a maximum window size for decodes. This allows rejecting packets that will cause big memory usage. The Decoder will likely allocate more memory based on the WithDecoderLowmem setting. If WithDecoderMaxMemory is set to a lower value, that will be used. Default is 512MB, Maximum is ~3.75 TB as per zstandard spec.
type Decoder ¶
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 ¶
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 will considerably reduce the allocations normally caused by NewReader.
func (*Decoder) Close ¶
func (d *Decoder) Close()
Close will release all resources. It is NOT possible to reuse the decoder after this.
func (*Decoder) DecodeAll ¶
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 ¶ added in v1.9.5
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 ¶
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 ¶
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. Reset can be called with a nil reader to release references to the previous reader. After being called with a nil reader, no other operations than Reset or DecodeAll or Close should be used.
type EOption ¶ added in v1.6.0
type EOption func(*encoderOptions) error
EOption is an option for creating a encoder.
func WithAllLitEntropyCompression ¶ added in v1.10.10
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 ¶ added in v1.6.0
WithEncoderCRC will add CRC value to output. Output will be 4 bytes larger.
func WithEncoderConcurrency ¶ added in v1.6.0
WithEncoderConcurrency will set the concurrency, meaning the maximum number of encoders to run concurrently. The value supplied must be at least 1. For streams, setting a value of 1 will disable async compression. By default this will be set to GOMAXPROCS.
func WithEncoderDict ¶ added in v1.11.0
WithEncoderDict allows to register a dictionary that will be used for the encode.
The slice dict must be in the dictionary format produced by "zstd --train" from the Zstandard reference implementation.
The encoder *may* choose to use no dictionary instead for certain payloads.
func WithEncoderDictRaw ¶ added in v1.15.15
WithEncoderDictRaw registers a dictionary that may be used by the encoder.
The slice content may contain arbitrary data. It will be used as an initial history.
Example ¶
package main import ( "bytes" "fmt" "github.com/klauspost/compress/zstd" ) func main() { // "Raw" dictionaries can be used for compressed delta encoding. source := []byte(` This is the source file. Compression of the target file with the source file as the dictionary will produce a compressed delta encoding of the target file.`) target := []byte(` This is the target file. Decompression of the delta encoding with the source file as the dictionary will produce this file.`) // The dictionary id is arbitrary. We use zero for compatibility // with zstd --patch-from, but applications can use any id // not in the range [32768, 1<<31). const id = 0 bestLevel := zstd.WithEncoderLevel(zstd.SpeedBestCompression) w, _ := zstd.NewWriter(nil, bestLevel, zstd.WithEncoderDictRaw(id, source)) delta := w.EncodeAll(target, nil) r, _ := zstd.NewReader(nil, zstd.WithDecoderDictRaw(id, source)) out, err := r.DecodeAll(delta, nil) if err != nil || !bytes.Equal(out, target) { panic("decoding error") } // Ordinary compression, for reference. w, _ = zstd.NewWriter(nil, bestLevel) compressed := w.EncodeAll(target, nil) // Check that the delta is at most half as big as the compressed file. fmt.Println(len(delta) < len(compressed)/2) }
Output: true
func WithEncoderLevel ¶ added in v1.7.0
func WithEncoderLevel(l EncoderLevel) EOption
WithEncoderLevel specifies a predefined compression level.
func WithEncoderPadding ¶ added in v1.6.1
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 WithLowerEncoderMem ¶ added in v1.11.13
WithLowerEncoderMem will trade in some memory cases trade less memory usage for slower encoding speed. This will not change the window size which is the primary function for reducing memory usage. See WithWindowSize.
func WithNoEntropyCompression ¶ added in v1.9.4
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 ¶ added in v1.6.0
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 and the window size. This setting has no effect on streamed encodes.
func WithWindowSize ¶ added in v1.8.3
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 and max 8MB.
func WithZeroFrames ¶ added in v1.8.2
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 ¶ added in v1.6.0
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 ¶ added in v1.6.0
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 ¶ added in v1.6.0
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 ¶ added in v1.6.0
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 ¶ added in v1.6.0
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) MaxEncodedSize ¶ added in v1.15.13
MaxEncodedSize returns the expected maximum size of an encoded block or stream.
func (*Encoder) ReadFrom ¶ added in v1.6.0
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 ¶ added in v1.6.0
Reset will re-initialize the writer and new writes will encode to the supplied writer as a new, independent stream.
func (*Encoder) ResetContentSize ¶ added in v1.13.4
ResetContentSize will reset and set a content size for the next stream. If the bytes written does not match the size given an error will be returned when calling Close(). This is removed when Reset is called. Sizes <= 0 results in no content size set.
type EncoderLevel ¶ added in v1.7.0
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). SpeedDefault // 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. SpeedBetterCompression // SpeedBestCompression will choose the best available compression option. // This will offer the best compression no matter the CPU cost. SpeedBestCompression )
func EncoderLevelFromString ¶ added in v1.7.0
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 ¶ added in v1.7.0
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 ¶ added in v1.7.0
func (e EncoderLevel) String() string
String provides a string representation of the compression level.
type Header ¶ added in v1.11.4
type Header struct { // SingleSegment specifies whether the data is to be decompressed into a // single contiguous memory segment. // It implies that WindowSize is invalid and that FrameContentSize is valid. SingleSegment bool // WindowSize is the window of data to keep while decoding. // Will only be set if SingleSegment is false. WindowSize uint64 // Dictionary ID. // If 0, no dictionary. DictionaryID uint32 // HasFCS specifies whether FrameContentSize has a valid value. HasFCS bool // FrameContentSize is the expected uncompressed size of the entire frame. FrameContentSize uint64 // Skippable will be true if the frame is meant to be skipped. // This implies that FirstBlock.OK is false. Skippable bool // SkippableID is the user-specific ID for the skippable frame. // Valid values are between 0 to 15, inclusive. SkippableID int // SkippableSize is the length of the user data to skip following // the header. SkippableSize uint32 // HeaderSize is the raw size of the frame header. // // For normal frames, it includes the size of the magic number and // the size of the header (per section 3.1.1.1). // It does not include the size for any data blocks (section 3.1.1.2) nor // the size for the trailing content checksum. // // For skippable frames, this counts the size of the magic number // along with the size of the size field of the payload. // It does not include the size of the skippable payload itself. // The total frame size is the HeaderSize plus the SkippableSize. HeaderSize int // First block information. FirstBlock struct { // OK will be set if first block could be decoded. OK bool // Is this the last block of a frame? Last bool // Is the data compressed? // If true CompressedSize will be populated. // Unfortunately DecompressedSize cannot be determined // without decoding the blocks. Compressed bool // DecompressedSize is the expected decompressed size of the block. // Will be 0 if it cannot be determined. DecompressedSize int // CompressedSize of the data in the block. // Does not include the block header. // Will be equal to DecompressedSize if not Compressed. CompressedSize int } // If set there is a checksum present for the block content. // The checksum field at the end is always 4 bytes long. HasCheckSum bool }
Header contains information about the first frame and block within that.
func (*Header) AppendTo ¶ added in v1.17.5
AppendTo will append the encoded header to the dst slice. There is no error checking performed on the header values.
func (*Header) Decode ¶ added in v1.11.4
Decode the header from the beginning of the stream. This will decode the frame header and the first block header if enough bytes are provided. It is recommended to provide at least HeaderMaxSize bytes. If the frame header cannot be read an error will be returned. If there isn't enough input, io.ErrUnexpectedEOF is returned. The FirstBlock.OK will indicate if enough information was available to decode the first block header.
func (*Header) DecodeAndStrip ¶ added in v1.17.5
DecodeAndStrip will decode the header from the beginning of the stream and on success return the remaining bytes. This will decode the frame header and the first block header if enough bytes are provided. It is recommended to provide at least HeaderMaxSize bytes. If the frame header cannot be read an error will be returned. If there isn't enough input, io.ErrUnexpectedEOF is returned. The FirstBlock.OK will indicate if enough information was available to decode the first block header.
type SnappyConverter ¶ added in v1.6.0
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.
Source Files ¶
- bitreader.go
- bitwriter.go
- blockdec.go
- blockenc.go
- blocktype_string.go
- bytebuf.go
- bytereader.go
- decodeheader.go
- decoder.go
- decoder_options.go
- dict.go
- enc_base.go
- enc_best.go
- enc_better.go
- enc_dfast.go
- enc_fast.go
- encoder.go
- encoder_options.go
- framedec.go
- frameenc.go
- fse_decoder.go
- fse_decoder_amd64.go
- fse_encoder.go
- fse_predefined.go
- hash.go
- history.go
- matchlen_amd64.go
- seqdec.go
- seqdec_amd64.go
- seqenc.go
- snappy.go
- zip.go
- zstd.go