use super::super::ma_sampling::{MaRefPlane, walk_channel_ma};
use super::super::predictor::predictor_value;
use super::super::tree::{push_leaf_mul, push_split};
use crate::entropy::{Token, pack_signed};
use crate::ma_tree::{LearnedTree, MaNode, MaSamples};
use crate::weighted_predictor::WpParams;
pub(super) const LM_SAMPLE_TARGET: usize = 1 << 16;
pub(super) const LM_BUDGET_DIV: usize = 1024;
pub(super) const LM_BUDGET_CAP: usize = 256;
pub(super) const LM_SAFE_PRED_MASK: u16 =
(1 << 0) | (1 << 1) | (1 << 2) | (1 << 4) | (1 << 5) | (1 << 7) | (1 << 8) | (1 << 9);
pub(super) fn scale_ma_value_props(samples: &mut MaSamples, q: i32) {
if q <= 1 {
return;
}
for p in samples.props.iter_mut() {
for v in &mut p[4..=14] {
*v *= q;
}
}
}
#[allow(clippy::too_many_arguments)]
pub(super) fn tokenize_channel_ma_mult<'a>(
get_row: impl Fn(usize) -> &'a [i32],
gw: usize,
gh: usize,
chan: u32,
stream: i32,
q: i32,
tree: &LearnedTree,
leaf_ctx: &[u32],
base: u32,
refs: &[MaRefPlane<'a>],
out: &mut Vec<Token>,
) {
walk_channel_ma(
get_row,
gw,
gh,
chan,
stream,
refs,
WpParams::DEFAULT,
false,
|_x, _y, v, p, n, _wp_pred| {
let (node, pred) = if q > 1 {
let mut sp = *p;
for s in &mut sp[4..=14] {
*s *= q;
}
tree.lookup(&sp)
} else {
tree.lookup(p)
};
let pv = predictor_value(pred, n, 0);
out.push(Token::new(
leaf_ctx[(base + node) as usize],
pack_signed((v - pv) as i32),
));
},
);
}
pub(super) fn emit_lm_forest(
trees: &[LearnedTree],
tag_mults: &[u32],
split: usize,
n_dc_slots: usize,
num_dc_groups: usize,
) -> (Vec<Token>, Vec<u32>, Vec<u32>, u32) {
let n_tags = trees.len();
let n_ac_slots = n_tags - split - n_dc_slots;
debug_assert!(split > 0 && (n_ac_slots > 0 || n_dc_slots == 0));
let mut nodes: Vec<MaNode> = Vec::new();
let mut mult_of: Vec<u32> = Vec::new();
let mut tag_base = vec![0u32; n_tags];
let append_tree = |nodes: &mut Vec<MaNode>, mult_of: &mut Vec<u32>, t: usize| -> u32 {
let base = nodes.len() as u32;
for n in &trees[t].nodes {
nodes.push(match *n {
MaNode::Split { prop, val, gt, le } => MaNode::Split {
prop,
val,
gt: gt + base,
le: le + base,
},
leaf @ MaNode::Leaf { .. } => leaf,
});
mult_of.push(tag_mults[t]);
}
base
};
let build_chain = |nodes: &mut Vec<MaNode>,
mult_of: &mut Vec<u32>,
tag_base: &mut [u32],
lo: usize,
n: usize|
-> u32 {
let base0 = append_tree(nodes, mult_of, lo);
tag_base[lo] = base0;
let mut acc = base0;
for k in 1..n {
let sub = append_tree(nodes, mult_of, lo + k);
tag_base[lo + k] = sub;
nodes.push(MaNode::Split {
prop: 0,
val: (k - 1) as i32,
gt: sub,
le: acc,
});
mult_of.push(1);
acc = (nodes.len() - 1) as u32;
}
acc
};
let global_root = build_chain(&mut nodes, &mut mult_of, &mut tag_base, 0, split);
if n_ac_slots == 0 {
return emit_forest_bfs(&nodes, &mult_of, global_root, tag_base);
}
let ac_root = build_chain(
&mut nodes,
&mut mult_of,
&mut tag_base,
split + n_dc_slots,
n_ac_slots,
);
let low_root = if n_dc_slots > 0 {
let dc_root = build_chain(&mut nodes, &mut mult_of, &mut tag_base, split, n_dc_slots);
nodes.push(MaNode::Split {
prop: 1,
val: 0,
gt: dc_root,
le: global_root,
});
mult_of.push(1);
(nodes.len() - 1) as u32
} else {
global_root
};
nodes.push(MaNode::Split {
prop: 1,
val: (2 * num_dc_groups) as i32,
gt: ac_root,
le: low_root,
});
mult_of.push(1);
let root = (nodes.len() - 1) as u32;
emit_forest_bfs(&nodes, &mult_of, root, tag_base)
}
pub(super) fn emit_forest_bfs(
nodes: &[MaNode],
mult_of: &[u32],
root: u32,
tag_base: Vec<u32>,
) -> (Vec<Token>, Vec<u32>, Vec<u32>, u32) {
use std::collections::VecDeque;
let mut tokens = Vec::new();
let mut leaf_ctx = vec![u32::MAX; nodes.len()];
let mut queue: VecDeque<u32> = VecDeque::new();
queue.push_back(root);
let mut ctx = 0u32;
while let Some(i) = queue.pop_front() {
match nodes[i as usize] {
MaNode::Split { prop, val, gt, le } => {
push_split(&mut tokens, prop as u32, val);
queue.push_back(gt);
queue.push_back(le);
}
MaNode::Leaf { pred, .. } => {
push_leaf_mul(&mut tokens, pred, mult_of[i as usize]);
leaf_ctx[i as usize] = ctx;
ctx += 1;
}
}
}
(tokens, leaf_ctx, tag_base, ctx)
}