compression

const (
	HASH_SHIFT = 5
	HASH_MASK  = 32767
)

const (
	// Minimum and maximum length that can be encoded in deflate.
	MAX_MATCH = 258
	MIN_MATCH = 3

	// The window size for deflate. Must be a power of two. This should be
	// 32768, the maximum possible by the deflate spec. Anything less hurts
	// compression more than speed.
	WINDOW_SIZE = 32768

	// The window mask used to wrap indices into the window. This is why the
	// window size must be a power of two.
	WINDOW_MASK = (WINDOW_SIZE - 1)

	// A block structure of huge, non-smart, blocks to divide the input into, to allow
	// operating on huge files without exceeding memory, such as the 1GB wiki9 corpus.
	// The whole compression algorithm, including the smarter block splitting, will
	// be executed independently on each huge block.
	// Dividing into huge blocks hurts compression, but not much relative to the size.
	// Set this to, for example, 20MB (20000000). Set it to 0 to disable master blocks.
	MASTER_BLOCK_SIZE = 20000000

	// For longest match cache. max 256. Uses huge amounts of memory but makes it
	// faster. Uses this many times three bytes per single byte of the input data.
	// This is so because longest match finding has to find the exact distance
	// that belongs to each length for the best lz77 strategy.
	// Good values: e.g. 5, 8.
	CACHE_LENGTH = 8

	// limit the max hash chain hits for this hash value. This has an effect only
	// on files where the hash value is the same very often. On these files, this
	// gives worse compression (the value should ideally be 32768, which is the
	// WINDOW_SIZE, while zlib uses 4096 even for best level), but makes it
	// faster on some specific files.
	// Good value: e.g. 8192.
	MAX_CHAIN_HITS = 8192

	// Whether to use the longest match cache for FindLongestMatch. This cache
	// consumes a lot of memory but speeds it up. No effect on compression size.
	LONGEST_MATCH_CACHE = true

	// Enable to remember amount of successive identical bytes in the hash chain for
	// finding longest match
	// required for HASH_SAME_HASH and SHORTCUT_LONG_REPETITIONS
	// This has no effect on the compression result, and enabling it increases speed.
	HASH_SAME = true

	// Switch to a faster hash based on the info from HASH_SAME once the
	// best length so far is long enough. This is way faster for files with lots of
	// identical bytes, on which the compressor is otherwise too slow. Regular files
	// are unaffected or maybe a tiny bit slower.
	// This has no effect on the compression result, only on speed.
	HASH_SAME_HASH = true

	// Enable this, to avoid slowness for files which are a repetition of the same
	// character more than a multiple of MAX_MATCH times. This should not affect
	// the compression result.
	SHORTCUT_LONG_REPETITIONS = true

	// Whether to use lazy matching in the greedy LZ77 implementation. This gives a
	// better result of LZ77Greedy, but the effect this has on the optimal LZ77
	// varies from file to file.
	LAZY_MATCHING = true
)

const (
	FORMAT_GZIP = iota
	FORMAT_ZLIB
	FORMAT_DEFLATE
)

const (
	UNCOMPRESSED_BLOCK = iota
	FIXED_BLOCK
	DYNAMIC_BLOCK
)