Function encodeBlockBetterDict

s2/encode_better.go:902–1513

encodeBlockBetterDict encodes a non-empty src to a guaranteed-large-enough dst. It assumes that the varint-encoded length of the decompressed bytes has already been written. It also assumes that: len(dst) >= MaxEncodedLen(len(src)) && minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSiz

(dst, src []byte, dict *Dict)

//	len(dst) >= MaxEncodedLen(len(src)) &&
//	minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
func encodeBlockBetterDict(dst, src []byte, dict *Dict) (d int) {
	// sLimit is when to stop looking for offset/length copies. The inputMargin
	// lets us use a fast path for emitLiteral in the main loop, while we are
	// looking for copies.
	// Initialize the hash tables.
	const (
		// Long hash matches.
		lTableBits    = betterLongTableBits
		maxLTableSize = betterLongTableSize

		// Short hash matches.
		sTableBits    = betterShortTableBits
		maxSTableSize = betterShortTableSize

		maxAhead = 8 // maximum bytes ahead without checking sLimit

		debug = false
	)

	sLimit := min(len(src)-inputMargin, MaxDictSrcOffset-maxAhead)
	if len(src) < minNonLiteralBlockSize {
		return 0
	}

	dict.initBetter()

	tbl := getBetterTables()
	lTable := &tbl.lTable
	sTable := &tbl.sTable
	defer betterTablePool.Put(tbl)

	// Bail if we can't compress to at least this.
	dstLimit := len(src) - len(src)>>5 - 6

	// nextEmit is where in src the next emitLiteral should start from.
	nextEmit := 0

	// The encoded form must start with a literal, as there are no previous
	// bytes to copy, so we start looking for hash matches at s == 1.
	s := 0
	cv := load64(src, s)

	// We initialize repeat to 0, so we never match on first attempt
	repeat := len(dict.dict) - dict.repeat

	// While in dict
searchDict:
	for {
		candidateL := 0
		nextS := 0
		for {
			// Next src position to check
			nextS = s + (s-nextEmit)>>7 + 1
			if nextS > sLimit {
				break searchDict
			}
			hashL := hash7(cv, lTableBits)
			hashS := hash4(cv, sTableBits)