use super::super::tree::{
NUM_TREE_CONTEXTS, build_balanced_tree_tokens, build_balanced_tree_tokens_offsets,
};
use super::{ConstantTail, LzToken, LzTokenSource, lz_tokens, lz77_length_encode};
use crate::bit_writer::BitWriter;
use crate::entropy::{EntropyCode, Token, optimize_entropy_code, write_entropy_code, write_token};
pub(in crate::lossless) fn write_lz_section<T: LzTokenSource>(
tokens: &[T],
distance_context: u32,
code: &EntropyCode<'_>,
min_symbol: u32,
w: &mut BitWriter,
) {
write_lz_section_tail(
tokens,
ConstantTail::NONE,
distance_context,
code,
min_symbol,
w,
);
}
pub(in crate::lossless) fn write_lz_section_tail<T: LzTokenSource>(
tokens: &[T],
tail: ConstantTail,
distance_context: u32,
code: &EntropyCode<'_>,
min_symbol: u32,
w: &mut BitWriter,
) {
if code.use_prefix_code {
for t in lz_tokens(tokens) {
write_lz_token(t, distance_context, code, min_symbol, w);
}
if tail.count > 0 {
let hist = code.context_map[tail.context as usize] as usize;
let (sym, nbits, _) =
crate::entropy::uint_encode_with_config(0, code.hybrid_uint_configs[hist]);
if nbits > 0 || code.prefix_codes[hist].depths[sym as usize] > 0 {
for _ in 0..tail.count {
write_lz_token(
LzToken::pixel(tail.context, 0),
distance_context,
code,
min_symbol,
w,
);
}
}
}
return;
}
let tail_hist = code.context_map[tail.context as usize] as usize;
let (tail_sym, tail_nbits, tail_bits) =
crate::entropy::uint_encode_with_config(0, code.hybrid_uint_configs[tail_hist]);
let tail_count = if tail.count > 0
&& (tail_nbits > 0
|| code.ans_symbols[tail_hist][tail_sym as usize].freq as u32
!= crate::entropy::ANS_TAB_SIZE)
{
tail.count
} else {
0
};
let expanded_len =
tokens.len() + lz_tokens(tokens).filter(|token| token.is_lz77()).count() + tail_count;
let mut present = vec![0u64; expanded_len.div_ceil(64)];
let mut emitted = Vec::with_capacity(expanded_len.min(16 * 1024));
let mut ordinal = 0usize;
let mut coder = crate::entropy::AnsCoder::new();
let mut put = |coder: &mut crate::entropy::AnsCoder, hist: usize, sym: u32| {
let start = hist * crate::entropy::ANS_TAB_SIZE as usize;
if let Some(word) = coder.put_symbol(
&code.ans_symbols[hist][sym as usize],
&code.ans_reverse_maps[start..start + crate::entropy::ANS_TAB_SIZE as usize],
) {
present[ordinal / 64] |= 1u64 << (ordinal % 64);
emitted.push(word);
}
ordinal += 1;
};
for _ in 0..tail_count {
put(&mut coder, tail_hist, tail_sym);
}
for t in lz_tokens(tokens).rev() {
let hist = code.context_map[t.context as usize] as usize;
if t.is_lz77() {
let dhist = code.context_map[distance_context as usize] as usize;
let (sym, _, _) = crate::entropy::uint_encode_with_config(
t.distance,
code.hybrid_uint_configs[dhist],
);
put(&mut coder, dhist, sym);
let (sym, _, _) = lz77_length_encode(t.value);
put(&mut coder, hist, min_symbol + sym);
} else {
let (sym, _, _) =
crate::entropy::uint_encode_with_config(t.value, code.hybrid_uint_configs[hist]);
put(&mut coder, hist, sym);
}
}
w.write(32, coder.state() as u64);
let mut emitted = emitted.into_iter().rev();
let mut write = |nbits: u32, bits: u32| {
ordinal -= 1;
if present[ordinal / 64] & (1u64 << (ordinal % 64)) != 0 {
let word = emitted.next().expect("one word per presence bit");
w.write(16, word as u64);
}
w.write(nbits as usize, bits as u64);
};
for t in lz_tokens(tokens) {
if t.is_lz77() {
let (_, nbits, bits) = lz77_length_encode(t.value);
write(nbits, bits);
let dhist = code.context_map[distance_context as usize] as usize;
let (_, nbits, bits) = crate::entropy::uint_encode_with_config(
t.distance,
code.hybrid_uint_configs[dhist],
);
write(nbits, bits);
} else {
let hist = code.context_map[t.context as usize] as usize;
let (_, nbits, bits) =
crate::entropy::uint_encode_with_config(t.value, code.hybrid_uint_configs[hist]);
write(nbits, bits);
}
}
for _ in 0..tail_count {
write(tail_nbits, tail_bits);
}
}
#[inline]
pub(in crate::lossless) fn write_lz_token(
t: LzToken,
distance_context: u32,
code: &EntropyCode<'_>,
min_symbol: u32,
w: &mut BitWriter,
) {
if t.is_lz77() {
let (len_tok, len_nbits, len_bits) = lz77_length_encode(t.value);
let sym = min_symbol + len_tok;
let pcluster = code.context_map[t.context as usize] as usize;
let pc = &code.prefix_codes[pcluster];
let d = pc.depths[sym as usize] as usize;
debug_assert!(
d > 0,
"LZ77 length symbol {} unrepresented in histogram",
sym
);
let data = (pc.bits[sym as usize] as u64) | ((len_bits as u64) << d);
w.write(d + len_nbits as usize, data);
let dcluster = code.context_map[distance_context as usize] as usize;
let dc = &code.prefix_codes[dcluster];
let (dist_symbol, dist_nbits, dist_bits) =
crate::entropy::uint_encode_with_config(t.distance, code.hybrid_uint_configs[dcluster]);
let dd = dc.depths[dist_symbol as usize] as usize;
if dd > 0 {
let data = dc.bits[dist_symbol as usize] as u64 | ((dist_bits as u64) << dd);
w.write(dd + dist_nbits as usize, data);
} else if dist_nbits != 0 {
w.write(dist_nbits as usize, dist_bits as u64);
}
} else {
let cluster = code.context_map[t.context as usize] as usize;
let (sym, nbits, bits) =
crate::entropy::uint_encode_with_config(t.value, code.hybrid_uint_configs[cluster]);
let pc = &code.prefix_codes[cluster];
let d = pc.depths[sym as usize] as usize;
let data = (pc.bits[sym as usize] as u64) | ((bits as u64) << d);
w.write(d + nbits as usize, data);
}
}
fn write_lz77_header(min_symbol: u32, w: &mut BitWriter) {
w.write(1, 1); w.write(2, 0b11);
w.write(15, (min_symbol - 8) as u64);
w.write(2, 0b00);
w.write(4, 4);
w.write(3, 0);
w.write(3, 0);
}
pub(in crate::lossless) fn write_local_tree_lz77(
predictors: &[u32],
pixel_code: &EntropyCode<'_>,
min_symbol: u32,
huffman_pool: &mut Vec<crate::entropy::HuffmanNode>,
w: &mut BitWriter,
) {
let tree_tokens = build_balanced_tree_tokens(predictors);
write_tree_lz77(&tree_tokens, pixel_code, min_symbol, huffman_pool, w);
}
pub(in crate::lossless) fn write_local_tree_lz77_offsets(
predictors: &[u32],
offsets: &[i32],
pixel_code: &EntropyCode<'_>,
min_symbol: u32,
huffman_pool: &mut Vec<crate::entropy::HuffmanNode>,
w: &mut BitWriter,
) {
let tree_tokens = build_balanced_tree_tokens_offsets(predictors, offsets);
write_tree_lz77(&tree_tokens, pixel_code, min_symbol, huffman_pool, w);
}
pub(in crate::lossless) fn write_tree_lz77(
tree_tokens: &[Token],
pixel_code: &EntropyCode<'_>,
min_symbol: u32,
huffman_pool: &mut Vec<crate::entropy::HuffmanNode>,
w: &mut BitWriter,
) {
let tree_code = optimize_entropy_code(tree_tokens, NUM_TREE_CONTEXTS, huffman_pool);
let tree_code_ref = tree_code.as_ref();
w.write(1, 0);
write_entropy_code(&tree_code_ref, huffman_pool, w);
for tok in tree_tokens {
write_token(*tok, &tree_code_ref, w);
}
write_lz77_header(min_symbol, w);
write_entropy_code(pixel_code, huffman_pool, w);
}