agila_open_tool/tools/v/vlib/compress/deflate/deflate_compress.v

module deflate

import hash.huffman

const deflate_hash_bits = 15
const deflate_hash_size = 1 << deflate_hash_bits
const deflate_max_chain = 64
const deflate_min_match = 3
const deflate_max_match = 258
const deflate_window = 32768

// fixed_litlen_encode returns (reversed_codes, code_lengths) for fixed Huffman lit/len.
// The LSB-first (bit-reversed) codes come straight from the shared canonical
// builder, since the encoder writes bits LSB-first.
fn fixed_litlen_encode() !([]u32, []int) {
	lens := fixed_litlen_lengths()
	t := huffman.build(lengths: lens, max_bits: 9, bit_order: .lsb_first)!
	return t.codes, lens
}

// fixed_dist_encode returns (reversed_codes, code_lengths) for fixed Huffman distance.
fn fixed_dist_encode() ([]u32, []int) {
	mut codes := []u32{len: 30}
	for i in 0 .. 30 {
		codes[i] = bit_reverse(u32(i), 5)
	}
	return codes, []int{len: 30, init: 5}
}

fn length_code_info(length int) (int, int, int) {
	for i := length_bases.len - 1; i >= 0; i-- {
		if length >= length_bases[i] {
			return i, length - length_bases[i], length_extra_bits[i]
		}
	}
	return 0, 0, 0
}

fn dist_code_info(distance int) (int, int, int) {
	for i := dist_bases.len - 1; i >= 0; i-- {
		if distance >= dist_bases[i] {
			return i, distance - dist_bases[i], dist_extra_bits[i]
		}
	}
	return 0, 0, 0
}

fn hash3(data []u8, pos int) int {
	v := u32(data[pos]) | (u32(data[pos + 1]) << 8) | (u32(data[pos + 2]) << 16)
	return int((v * u32(2654435761)) >> u32(32 - deflate_hash_bits))
}

@[direct_array_access]
fn find_lz_match(data []u8, pos int, last []int, prev []int) (int, int) {
	if pos + deflate_min_match > data.len {
		return 0, 0
	}
	max_len := if pos + deflate_max_match < data.len { deflate_max_match } else { data.len - pos }
	mut best_len := 0
	mut best_off := 0
	mut i := last[hash3(data, pos)]
	mut chain := 0
	for i >= 0 && chain < deflate_max_chain {
		off := pos - i
		if off > deflate_window {
			break
		}
		mut l := 0
		for l < max_len && data[i + l] == data[pos + l] {
			l++
		}
		if l > best_len {
			best_len = l
			best_off = off
			if best_len == max_len {
				break
			}
		}
		i = prev[i]
		chain++
	}
	return best_off, best_len
}

struct BitWriter {
mut:
	buf   []u8
	bits  u32
	nbits int
}

@[direct_array_access; inline]
fn (mut w BitWriter) write_bits(value u32, nbits int) {
	if nbits == 0 {
		return
	}
	w.bits |= value << w.nbits
	w.nbits += nbits
	for w.nbits >= 8 {
		w.buf << u8(w.bits & 0xff)
		w.bits >>= 8
		w.nbits -= 8
	}
}

fn (mut w BitWriter) flush() {
	if w.nbits > 0 {
		w.buf << u8(w.bits & 0xff)
		w.bits = 0
		w.nbits = 0
	}
}

// deflate_compress_fixed compresses data to RFC 1951 DEFLATE using fixed Huffman codes.
@[direct_array_access]
fn deflate_compress_fixed(data []u8) ![]u8 {
	ll_codes, ll_lens := fixed_litlen_encode()!
	d_codes, d_lens := fixed_dist_encode()
	mut w := BitWriter{}
	// BFINAL=1, BTYPE=01 (fixed Huffman)
	w.write_bits(1, 1)
	w.write_bits(1, 2)
	if data.len == 0 {
		w.write_bits(ll_codes[256], ll_lens[256])
		w.flush()
		return w.buf
	}
	mut last := []int{len: deflate_hash_size, init: -1}
	mut prev := []int{len: data.len, init: -1}
	mut pos := 0
	for pos < data.len {
		off, match_len := find_lz_match(data, pos, last, prev)
		if match_len >= deflate_min_match {
			li, lext, lext_bits := length_code_info(match_len)
			sym := 257 + li
			w.write_bits(ll_codes[sym], ll_lens[sym])
			w.write_bits(u32(lext), lext_bits)
			di, dext, dext_bits := dist_code_info(off)
			w.write_bits(d_codes[di], d_lens[di])
			w.write_bits(u32(dext), dext_bits)
			for i in pos .. pos + match_len {
				if i + deflate_min_match < data.len {
					h := hash3(data, i)
					prev[i] = last[h]
					last[h] = i
				}
			}
			pos += match_len
		} else {
			w.write_bits(ll_codes[int(data[pos])], ll_lens[int(data[pos])])
			if pos + deflate_min_match < data.len {
				h := hash3(data, pos)
				prev[pos] = last[h]
				last[h] = pos
			}
			pos++
		}
	}
	w.write_bits(ll_codes[256], ll_lens[256])
	w.flush()
	return w.buf
}