use super::ma_sampling::{MaRefPlane, walk_channel_ma};
use super::predictor::predictor_value;
use 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(crate) const SAFE_PREDICTORS: u16 =
(1 << 0) | (1 << 1) | (1 << 2) | (1 << 4) | (1 << 5) | (1 << 7) | (1 << 8) | (1 << 9);
pub(crate) fn scale_ma_value_props(samples: &mut MaSamples, q: i32) {
if q <= 1 {
return;
}
samples.props.map_rows(|p| {
for v in &mut p[4..=14] {
*v *= q;
}
});
}
#[allow(clippy::too_many_arguments)]
pub(crate) 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(crate) 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)
}