package huff0

Import Path
	github.com/klauspost/compress/huff0 (on go.dev)

Dependency Relation
	imports 10 packages, and imported by one package


Involved Source Files

	    bitreader.go
	    bitwriter.go
	    compress.go
	    decompress.go
	
		This file contains the specialisation of Decoder.Decompress4X
		and Decoder.Decompress1X that use an asm implementation of thir main loops.

	
		Package huff0 provides fast huffman encoding as used in zstd.
		
		See README.md at https://github.com/klauspost/compress/tree/master/huff0 for details.

	    decompress_amd64.s


Package-Level Type Names (total 13, in which 3 are exported)


	/* sort exporteds by:  |  */
	
		Decoder provides stateless decoding.

		
			
		
			
				Decompress1X will decompress a 1X encoded stream.
				The cap of the output buffer will be the maximum decompressed size.
				The length of the supplied input must match the end of a block exactly.

			
				Decompress4X will decompress a 4X encoded stream.
				The length of the supplied input must match the end of a block exactly.
				The *capacity* of the dst slice must match the destination size of
				the uncompressed data exactly.

			
		
			func (*Scratch).Decoder() *Decoder


	

		
			const ReusePolicyAllow
			const ReusePolicyMust
			const ReusePolicyNone
			const ReusePolicyPrefer


	

		
			
				MaxDecodedSize will set the maximum allowed output size.
				This value will automatically be set to BlockSizeMax if not set.
				Decoders will return ErrMaxDecodedSizeExceeded is this limit is exceeded.

			
				MaxSymbolValue will override the maximum symbol value of the next block.

			
				Out is output buffer.
				If the scratch is re-used before the caller is done processing the output,
				set this field to nil.
				Otherwise the output buffer will be re-used for next Compression/Decompression step
				and allocation will be avoided.

			
				OutData will contain the compressed data.
				Slice of the returned data.

			
				OutTable will contain the table data only, if a new table has been generated.
				Slice of the returned data.

			
				Reuse will specify the reuse policy

			
				TableLog will attempt to override the tablelog for the next block.
				Must be <= 11 and >= 5.

			
				WantLogLess allows to specify a log 2 reduction that should at least be achieved,
				otherwise the block will be returned as incompressible.
				The reduction should then at least be (input size >> WantLogLess)
				If WantLogLess == 0 any improvement will do.

			
		
			
				Decoder will return a stateless decoder that can be used by multiple
				decompressors concurrently.
				Before this is called, the table must be initialized with ReadTable.
				The Decoder is still linked to the scratch buffer so that cannot be reused.
				However, it is safe to discard the scratch.

			
				Decompress1X will decompress a 1X encoded stream.
				The length of the supplied input must match the end of a block exactly.
				Before this is called, the table must be initialized with ReadTable unless
				the encoder re-used the table.
				deprecated: Use the stateless Decoder() to get a concurrent version.

			
				Decompress4X will decompress a 4X encoded stream.
				Before this is called, the table must be initialized with ReadTable unless
				the encoder re-used the table.
				The length of the supplied input must match the end of a block exactly.
				The destination size of the uncompressed data must be known and provided.
				deprecated: Use the stateless Decoder() to get a concurrent version.

			
				TransferCTable will transfer the previously used compression table.

			
		
			func ReadTable(in []byte, s *Scratch) (s2 *Scratch, remain []byte, err error)
			
		
			func Compress1X(in []byte, s *Scratch) (out []byte, reUsed bool, err error)
			func Compress4X(in []byte, s *Scratch) (out []byte, reUsed bool, err error)
			func EstimateSizes(in []byte, s *Scratch) (tableSz, dataSz, reuseSz int, err error)
			func ReadTable(in []byte, s *Scratch) (s2 *Scratch, remain []byte, err error)
			func (*Scratch).TransferCTable(src *Scratch)
			


	


Package-Level Functions (total 11, in which 4 are exported)


	
		Compress1X will compress the input.
		The output can be decoded using Decompress1X.
		Supply a Scratch object. The scratch object contains state about re-use,
		So when sharing across independent encodes, be sure to set the re-use policy.


	
		Compress4X will compress the input. The input is split into 4 independent blocks
		and compressed similar to Compress1X.
		The output can be decoded using Decompress4X.
		Supply a Scratch object. The scratch object contains state about re-use,
		So when sharing across independent encodes, be sure to set the re-use policy.


	
		EstimateSizes will estimate the data sizes


	
		ReadTable will read a table from the input.
		The size of the input may be larger than the table definition.
		Any content remaining after the table definition will be returned.
		If no Scratch is provided a new one is allocated.
		The returned Scratch can be used for encoding or decoding input using this table.


	


Package-Level Variables (total 5, in which 4 are exported)


	
		ErrIncompressible is returned when input is judged to be too hard to compress.


	
		ErrMaxDecodedSizeExceeded is return if input is too large for a single block.


	
		ErrTooBig is return if input is too large for a single block.


	
		ErrUseRLE is returned from the compressor when the input is a single byte value repeated.


	


Package-Level Constants (total 14, in which 5 are exported)


	
		BlockSizeMax is maximum input size for a single block uncompressed.


	
		ReusePolicyAllow will allow reuse if it produces smaller output.


	
		ReusePolicyMust must allow reuse and produce smaller output.


	
		ReusePolicyNone will disable re-use of tables.
		This is slightly faster than ReusePolicyAllow but may produce larger output.


	
		ReusePolicyPrefer will re-use aggressively if possible.
		This will not check if a new table will produce smaller output,
		except if the current table is impossible to use or
		compressed output is bigger than input.