func CompressBlock(src, dst []byte, hashTable []int) (di int, err error) {
	defer func() {
		if recover() != nil {
			err = ErrInvalidSourceShortBuffer
		}
	}()

	sn, dn := len(src)-mfLimit, len(dst)
	if sn <= 0 || dn == 0 {
		return 0, nil
	}
	var si int

	// Fast scan strategy: the hash table only stores the last 4 bytes sequences.
	// const accInit = 1 << skipStrength

	anchor := si // Position of the current literals.
	// acc := accInit // Variable step: improves performance on non-compressible data.

	for si < sn {
		// Hash the next 4 bytes (sequence)...
		match := binary.LittleEndian.Uint32(src[si:])
		h := blockHash(match)

		ref := hashTable[h]
		hashTable[h] = si
		if ref >= sn { // Invalid reference (dirty hashtable).
			si++
			continue
		}
		offset := si - ref
		if offset <= 0 || offset >= winSize || // Out of window.
			match != binary.LittleEndian.Uint32(src[ref:]) { // Hash collision on different matches.
			// si += acc >> skipStrength
			// acc++
			si++
			continue
		}

		// Match found.
		// acc = accInit
		lLen := si - anchor // Literal length.

		// Encode match length part 1.
		si += minMatch
		mLen := si // Match length has minMatch already.
		// Find the longest match, first looking by batches of 8 bytes.
		for si < sn && binary.LittleEndian.Uint64(src[si:]) == binary.LittleEndian.Uint64(src[si-offset:]) {
			si += 8
		}
		// Then byte by byte.
		for si < sn && src[si] == src[si-offset] {
			si++
		}

		mLen = si - mLen
		if mLen < 0xF {
			dst[di] = byte(mLen)
		} else {
			dst[di] = 0xF
		}

		// Encode literals length.
		if lLen < 0xF {
			dst[di] |= byte(lLen << 4)
		} else {
			dst[di] |= 0xF0
			di++
			l := lLen - 0xF
			for ; l >= 0xFF; l -= 0xFF {
				dst[di] = 0xFF
				di++
			}
			dst[di] = byte(l)
		}
		di++

		// Literals.
		copy(dst[di:di+lLen], src[anchor:anchor+lLen])
		di += lLen + 2
		anchor = si

		// Encode offset.
		_ = dst[di] // Bound check elimination.
		dst[di-2], dst[di-1] = byte(offset), byte(offset>>8)

		// Encode match length part 2.
		if mLen >= 0xF {
			for mLen -= 0xF; mLen >= 0xFF; mLen -= 0xFF {
				dst[di] = 0xFF
				di++
			}
			dst[di] = byte(mLen)
			di++
		}
	}

	if anchor == 0 {
		// Incompressible.
		return 0, nil
	}

	// Last literals.
	lLen := len(src) - anchor
	if lLen < 0xF {
		dst[di] = byte(lLen << 4)
	} else {
		dst[di] = 0xF0
		di++
		for lLen -= 0xF; lLen >= 0xFF; lLen -= 0xFF {
			dst[di] = 0xFF
			di++
		}
		dst[di] = byte(lLen)
	}
	di++

	// Write the last literals.
	if di >= anchor {
		// Incompressible.
		return 0, nil
	}
	di += copy(dst[di:di+len(src)-anchor], src[anchor:])
	return di, nil
}
func CompressBlock(src, dst []byte, hashTable []int) (di int, err error) {
	defer func() {
		if recover() != nil {
			err = ErrInvalidSourceShortBuffer
		}
	}()

	sn, dn := len(src)-mfLimit, len(dst)
	if sn <= 0 || dn == 0 {
		return 0, nil
	}
	var si int

	
	

	anchor := si 
	

	for si < sn {
		
		match := binary.LittleEndian.Uint32(src[si:])
		h := blockHash(match)

		ref := hashTable[h]
		hashTable[h] = si
		if ref >= sn { 
			si++
			continue
		}
		offset := si - ref
		if offset <= 0 || offset >= winSize || 
			match != binary.LittleEndian.Uint32(src[ref:]) { 
			
			
			si++
			continue
		}

		
		
		lLen := si - anchor 

		
		si += minMatch
		mLen := si 
		
		for si < sn && binary.LittleEndian.Uint64(src[si:]) == binary.LittleEndian.Uint64(src[si-offset:]) {
			si += 8
		}
		
		for si < sn && src[si] == src[si-offset] {
			si++
		}

		mLen = si - mLen
		if mLen < 0xF {
			dst[di] = byte(mLen)
		} else {
			dst[di] = 0xF
		}

		
		if lLen < 0xF {
			dst[di] |= byte(lLen << 4)
		} else {
			dst[di] |= 0xF0
			di++
			l := lLen - 0xF
			for ; l >= 0xFF; l -= 0xFF {
				dst[di] = 0xFF
				di++
			}
			dst[di] = byte(l)
		}
		di++

		
		copy(dst[di:di+lLen], src[anchor:anchor+lLen])
		di += lLen + 2
		anchor = si

		
		_ = dst[di] 
		dst[di-2], dst[di-1] = byte(offset), byte(offset>>8)

		
		if mLen >= 0xF {
			for mLen -= 0xF; mLen >= 0xFF; mLen -= 0xFF {
				dst[di] = 0xFF
				di++
			}
			dst[di] = byte(mLen)
			di++
		}
	}

	if anchor == 0 {
		
		return 0, nil
	}

	
	lLen := len(src) - anchor
	if lLen < 0xF {
		dst[di] = byte(lLen << 4)
	} else {
		dst[di] = 0xF0
		di++
		for lLen -= 0xF; lLen >= 0xFF; lLen -= 0xFF {
			dst[di] = 0xFF
			di++
		}
		dst[di] = byte(lLen)
	}
	di++

	
	if di >= anchor {
		
		return 0, nil
	}
	di += copy(dst[di:di+len(src)-anchor], src[anchor:])
	return di, nil
}
func CompressBlock ( src , dst [ ] byte , hashTable [ ] int ) ( di int , err error ) { defer func ( ) { if recover ( ) != nil { err = ErrInvalidSourceShortBuffer } } ( ) sn , dn := len ( src ) - mfLimit , len ( dst ) if sn <= 0 || dn == 0 { return 0 , nil } var si int // Fast scan strategy: the hash table only stores the last 4 bytes sequences. // const accInit = 1 << skipStrength anchor := si // Position of the current literals. // acc := accInit // Variable step: improves performance on non-compressible data. for si < sn { // Hash the next 4 bytes (sequence)... match := binary . LittleEndian . Uint32 ( src [ si : ] ) h := blockHash ( match ) ref := hashTable [ h ] hashTable [ h ] = si if ref >= sn { // Invalid reference (dirty hashtable). si ++ continue } offset := si - ref if offset <= 0 || offset >= winSize || // Out of window. match != binary . LittleEndian . Uint32 ( src [ ref : ] ) { // Hash collision on different matches. // si += acc >> skipStrength // acc++ si ++ continue } // Match found. // acc = accInit lLen := si - anchor // Literal length. // Encode match length part 1. si += minMatch mLen := si // Match length has minMatch already. // Find the longest match, first looking by batches of 8 bytes. for si < sn && binary . LittleEndian . Uint64 ( src [ si : ] ) == binary . LittleEndian . Uint64 ( src [ si - offset : ] ) { si += 8 } // Then byte by byte. for si < sn && src [ si ] == src [ si - offset ] { si ++ } mLen = si - mLen if mLen < 0xF { dst [ di ] = byte ( mLen ) } else { dst [ di ] = 0xF } // Encode literals length. if lLen < 0xF { dst [ di ] |= byte ( lLen << 4 ) } else { dst [ di ] |= 0xF0 di ++ l := lLen - 0xF for ; l >= 0xFF ; l -= 0xFF { dst [ di ] = 0xFF di ++ } dst [ di ] = byte ( l ) } di ++ // Literals. copy ( dst [ di : di + lLen ] , src [ anchor : anchor + lLen ] ) di += lLen + 2 anchor = si // Encode offset. _ = dst [ di ] // Bound check elimination. dst [ di - 2 ] , dst [ di - 1 ] = byte ( offset ) , byte ( offset >> 8 ) // Encode match length part 2. if mLen >= 0xF { for mLen -= 0xF ; mLen >= 0xFF ; mLen -= 0xFF { dst [ di ] = 0xFF di ++ } dst [ di ] = byte ( mLen ) di ++ } } if anchor == 0 { // Incompressible. return 0 , nil } // Last literals. lLen := len ( src ) - anchor if lLen < 0xF { dst [ di ] = byte ( lLen << 4 ) } else { dst [ di ] = 0xF0 di ++ for lLen -= 0xF ; lLen >= 0xFF ; lLen -= 0xFF { dst [ di ] = 0xFF di ++ } dst [ di ] = byte ( lLen ) } di ++ // Write the last literals. if di >= anchor { // Incompressible. return 0 , nil } di += copy ( dst [ di : di + len ( src ) - anchor ] , src [ anchor : ] ) return di , nil }
// CompressBlock compresses the source buffer into the destination one.
// This is the fast version of LZ4 compression and also the default one.
// The size of hashTable must be at least 64Kb.
//
// The size of the compressed data is returned. If it is 0 and no error, then the data is incompressible.
//
// An error is returned if the destination buffer is too small.
CompressBlock compresses the source buffer into the destination one . This is the fast version of LZ4 compression and also the default one . The size of hashTable must be at least 64Kb . The size of the compressed data is returned . If it is 0 and no error then the data is incompressible . An error is returned if the destination buffer is too small .