use super::state::Dec;
use crate::hevc::intra::Refs;
pub fn gather_refs(d: &Dec<'_>, x: usize, y: usize, n: usize, c_idx: usize) -> Refs {
let (sw, sh) = if c_idx == 0 {
(1usize, 1usize)
} else {
(d.sps.sub_w, d.sps.sub_h)
};
let plane = match c_idx {
0 => &d.pic.y,
1 => &d.pic.cb,
_ => &d.pic.cr,
};
let bit_depth = if c_idx == 0 {
d.sps.bit_depth_y
} else {
d.sps.bit_depth_c
};
let (xc, yc) = (x * sw, y * sh);
let total = 4 * n + 1;
let (stride, data) = (plane.stride, plane.data.as_slice());
let mut r = Refs::new(n);
let mut avail = [false; 129];
let min_tb = 1usize << d.geo.min_tb_log2;
let (step_x, step_y) = ((min_tb / sw).max(1), (min_tb / sh).max(1));
let mut all = true;
let left_in = x > 0 && x - 1 < plane.width;
let above_in = y > 0 && y - 1 < plane.height;
if left_in {
let col = x - 1;
let mut k = 0;
while k < 2 * n {
let yy = y + k;
if yy >= plane.height {
all = false;
break;
}
if d.available(xc, yc, (col * sw) as isize, (yy * sh) as isize) {
let end = (yy + step_y).min(plane.height).min(y + 2 * n);
for (j, yj) in (yy..end).enumerate() {
r.buf[2 * n - 1 - k - j] = data[yj * stride + col];
avail[2 * n - 1 - k - j] = true;
}
} else {
all = false;
}
k += step_y;
}
} else {
all = false;
}
if left_in && above_in && d.available(xc, yc, ((x - 1) * sw) as isize, ((y - 1) * sh) as isize)
{
r.buf[2 * n] = data[(y - 1) * stride + x - 1];
avail[2 * n] = true;
} else {
all = false;
}
if above_in {
let row = (y - 1) * stride;
let mut k = 0;
while k < 2 * n {
let xx = x + k;
if xx >= plane.width {
all = false;
break;
}
if d.available(xc, yc, (xx * sw) as isize, ((y - 1) * sh) as isize) {
let end = (xx + step_x).min(plane.width).min(x + 2 * n);
let i0 = 2 * n + 1 + k;
for (j, &v) in data[row + xx..row + end].iter().enumerate() {
r.buf[i0 + j] = v;
avail[i0 + j] = true;
}
} else {
all = false;
}
k += step_x;
}
} else {
all = false;
}
if !all {
substitute(&mut r, &avail, total, bit_depth);
}
r
}
fn substitute(r: &mut Refs, avail: &[bool; 129], total: usize, bit_depth: u8) {
if avail[..total].iter().all(|&a| !a) {
let mid = 1u16 << (bit_depth - 1);
r.buf[..total].fill(mid);
return;
}
if !avail[0] {
if let Some(i) = avail[..total].iter().position(|&a| a) {
r.buf[0] = r.buf[i];
}
}
let mut last = r.buf[0];
for (v, &a) in r.buf[..total].iter_mut().zip(avail[..total].iter()) {
if a {
last = *v;
} else {
*v = last;
}
}
}