use crate::bit_writer::BitWriter;
use crate::coder_scratch::CoderScratch;
use crate::entropy::{OwnedEntropyCode, Token, pack_signed, write_entropy_code};
use crate::ma_tree::{LearnedTree, MaNode};
pub(super) const TREE_CTX_SPLIT_VAL: u32 = 0;
pub(super) const TREE_CTX_PROPERTY: u32 = 1;
pub(super) const TREE_CTX_PREDICTOR: u32 = 2;
pub(super) const TREE_CTX_OFFSET: u32 = 3;
pub(super) const TREE_CTX_MULTIPLIER_LOG: u32 = 4;
pub(super) const TREE_CTX_MULTIPLIER_BITS: u32 = 5;
pub(super) const NUM_TREE_CONTEXTS: usize = 6;
pub(super) fn emit_learned_tree(tree: &LearnedTree) -> (Vec<Token>, Vec<u32>, u32) {
use std::collections::VecDeque;
let mut tokens = Vec::new();
let mut leaf_ctx = vec![u32::MAX; tree.nodes.len()];
let mut q: VecDeque<u32> = VecDeque::new();
q.push_back(0);
let mut ctx = 0u32;
while let Some(i) = q.pop_front() {
match tree.nodes[i as usize] {
MaNode::Split { prop, val, gt, le } => {
push_split(&mut tokens, prop as u32, val);
q.push_back(gt);
q.push_back(le);
}
MaNode::Leaf { pred, offset } => {
push_leaf_offset(&mut tokens, pred, offset);
leaf_ctx[i as usize] = ctx;
ctx += 1;
}
}
}
(tokens, leaf_ctx, ctx)
}
pub(crate) fn push_split(out: &mut Vec<Token>, property: u32, split_val: i32) {
out.push(Token::new(TREE_CTX_PROPERTY, property + 1));
out.push(Token::new(TREE_CTX_SPLIT_VAL, pack_signed(split_val)));
}
pub(super) fn push_leaf(out: &mut Vec<Token>, predictor: u32) {
push_leaf_mul(out, predictor, 1);
}
pub(super) fn push_leaf_offset(out: &mut Vec<Token>, predictor: u32, offset: i32) {
out.push(Token::new(TREE_CTX_PROPERTY, 0));
out.push(Token::new(TREE_CTX_PREDICTOR, predictor));
out.push(Token::new(TREE_CTX_OFFSET, pack_signed(offset)));
out.push(Token::new(TREE_CTX_MULTIPLIER_LOG, 0));
out.push(Token::new(TREE_CTX_MULTIPLIER_BITS, 0));
}
pub(super) fn build_balanced_tree_tokens_offsets(
predictors: &[u32],
offsets: &[i32],
) -> Vec<Token> {
debug_assert_eq!(predictors.len(), offsets.len());
let mut tokens = build_balanced_tree_tokens(predictors);
for (token, &offset) in tokens
.iter_mut()
.filter(|token| token.context == TREE_CTX_OFFSET)
.zip(offsets.iter().rev())
{
token.value = pack_signed(offset);
}
tokens
}
pub(crate) fn push_leaf_mul(out: &mut Vec<Token>, predictor: u32, multiplier: u32) {
debug_assert!(multiplier >= 1);
let mul_log = multiplier.trailing_zeros();
let mul_bits = (multiplier >> mul_log) - 1;
out.push(Token::new(TREE_CTX_PROPERTY, 0));
out.push(Token::new(TREE_CTX_PREDICTOR, predictor));
out.push(Token::new(TREE_CTX_OFFSET, pack_signed(0)));
out.push(Token::new(TREE_CTX_MULTIPLIER_LOG, mul_log));
out.push(Token::new(TREE_CTX_MULTIPLIER_BITS, mul_bits));
}
pub(crate) fn build_balanced_tree_tokens_mul(leaves: &[(u32, u32)]) -> Vec<Token> {
let n_leaves = leaves.len();
let mut t = Vec::new();
match n_leaves {
1 => push_leaf_mul(&mut t, leaves[0].0, leaves[0].1),
2 => {
push_split(&mut t, 0, 0);
push_leaf_mul(&mut t, leaves[1].0, leaves[1].1);
push_leaf_mul(&mut t, leaves[0].0, leaves[0].1);
}
_ => {
for k in (1..=(n_leaves - 2)).rev() {
push_split(&mut t, 0, k as i32);
push_leaf_mul(&mut t, leaves[k + 1].0, leaves[k + 1].1);
}
push_split(&mut t, 0, 0);
push_leaf_mul(&mut t, leaves[1].0, leaves[1].1);
push_leaf_mul(&mut t, leaves[0].0, leaves[0].1);
}
}
t
}
pub(super) fn build_balanced_tree_tokens(predictors: &[u32]) -> Vec<Token> {
let n_leaves = predictors.len();
let mut t = Vec::new();
match n_leaves {
1 => push_leaf(&mut t, predictors[0]),
2 => {
push_split(&mut t, 0, 0);
push_leaf(&mut t, predictors[1]); push_leaf(&mut t, predictors[0]); }
3 => {
push_split(&mut t, 0, 1);
push_leaf(&mut t, predictors[2]); push_split(&mut t, 0, 0);
push_leaf(&mut t, predictors[1]); push_leaf(&mut t, predictors[0]); }
4 => {
push_split(&mut t, 0, 1);
push_split(&mut t, 0, 2);
push_split(&mut t, 0, 0);
push_leaf(&mut t, predictors[3]); push_leaf(&mut t, predictors[2]); push_leaf(&mut t, predictors[1]); push_leaf(&mut t, predictors[0]); }
_ => {
for k in (1..=(n_leaves - 2)).rev() {
push_split(&mut t, 0, k as i32);
push_leaf(&mut t, predictors[k + 1]);
}
push_split(&mut t, 0, 0);
push_leaf(&mut t, predictors[1]);
push_leaf(&mut t, predictors[0]);
}
}
t
}
pub(super) fn write_tree_and_pixel_code_nolz(
tree_tokens: &[Token],
pixel_code: &OwnedEntropyCode,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
crate::entropy::write_raced_token_stream(
tree_tokens,
NUM_TREE_CONTEXTS,
&mut scratch.huffman_pool,
w,
);
w.write(1, 0);
write_entropy_code(&pixel_code.as_ref(), &mut scratch.huffman_pool, w);
}