use crate::internal::bpg_hevc_decode::DecodedFrame;
use crate::internal::bpg_hevc_decode::hevc::UNINIT_SAMPLE;
const CTB: usize = 64;
#[derive(Default)]
struct CanvasPlane {
buf: Vec<u16>,
stride: usize,
rows: usize,
origin_x: i64,
origin_y: i64,
bg_top: Vec<u16>,
bg_left: Vec<u16>,
}
impl CanvasPlane {
#[inline]
fn coords(&self, x: u32, y: u32) -> Option<(usize, usize)> {
let cx = x as i64 - self.origin_x;
let cy = y as i64 - self.origin_y;
if cx >= 0 && (cx as usize) < self.stride && cy >= 0 && (cy as usize) < self.rows {
Some((cx as usize, cy as usize))
} else {
None
}
}
fn reset(&mut self, frame: &DecodedFrame, c_idx: u8, ctu_x: u32, ctu_y: u32) {
let (sx, sy) =
crate::internal::bpg_hevc_decode::hevc::tile::plane_shifts(c_idx, frame.chroma_format);
let cw = CTB >> sx;
let ch = CTB >> sy;
let stride = 1 + 2 * cw;
let rows = 1 + 2 * ch;
self.stride = stride;
self.rows = rows;
self.origin_x = ((ctu_x >> sx) as i64) - 1;
self.origin_y = ((ctu_y >> sy) as i64) - 1;
self.buf.clear();
self.buf.resize(stride * rows, UNINIT_SAMPLE);
let (plane, pstride) = frame.plane(c_idx);
let plane_h = if pstride == 0 {
0
} else {
plane.len() / pstride
};
if self.origin_y >= 0 && (self.origin_y as usize) < plane_h {
let py = self.origin_y as usize;
let px0 = self.origin_x.max(0) as usize;
let px1 = ((self.origin_x + stride as i64).min(pstride as i64)).max(0) as usize;
if px0 < px1 {
let dst0 = (px0 as i64 - self.origin_x) as usize;
self.buf[dst0..dst0 + (px1 - px0)]
.copy_from_slice(&plane[py * pstride + px0..py * pstride + px1]);
}
}
if self.origin_x >= 0 && (self.origin_x as usize) < pstride {
let px = self.origin_x as usize;
let py0 = (self.origin_y + 1).max(0) as usize;
let py1 = ((self.origin_y + 1 + ch as i64).min(plane_h as i64)).max(0) as usize;
for py in py0..py1 {
let cy = (py as i64 - self.origin_y) as usize;
self.buf[cy * stride] = plane[py * pstride + px];
}
}
self.bg_top.clear();
self.bg_top.extend_from_slice(&self.buf[..stride]);
self.bg_left.clear();
self.bg_left
.extend((0..rows).map(|cy| self.buf[cy * stride]));
}
fn reset_from_strip(
&mut self,
strip: &[u16],
plane_h: usize,
left: Option<&[u16]>,
chroma_format: u8,
c_idx: u8,
ctu_x: u32,
ctu_y: u32,
) {
let (sx, sy) =
crate::internal::bpg_hevc_decode::hevc::tile::plane_shifts(c_idx, chroma_format);
let cw = CTB >> sx;
let ch = CTB >> sy;
let stride = 1 + 2 * cw;
let rows = 1 + 2 * ch;
let new_ox = ((ctu_x >> sx) as i64) - 1;
let new_oy = ((ctu_y >> sy) as i64) - 1;
let capture = left.is_none()
&& self.stride == stride
&& self.rows == rows
&& self.origin_y == new_oy
&& self.origin_x + cw as i64 == new_ox
&& !self.buf.is_empty();
debug_assert!(
left.is_some() || capture || new_ox < 0,
"frameless reset with a coded left neighbor but no left column \
(c={c_idx} ctu=({ctu_x},{ctu_y}))"
);
let mut left_col = [UNINIT_SAMPLE; CTB];
if capture {
for (i, v) in left_col[..ch].iter_mut().enumerate() {
*v = self.buf[(1 + i) * stride + cw];
}
} else if let Some(cols) = left {
let n = cols.len().min(ch);
left_col[..n].copy_from_slice(&cols[..n]);
}
self.stride = stride;
self.rows = rows;
self.origin_x = new_ox;
self.origin_y = new_oy;
self.buf.clear();
self.buf.resize(stride * rows, UNINIT_SAMPLE);
let plane_w = strip.len();
if new_oy >= 0 && (new_oy as usize) < plane_h {
let px0 = new_ox.max(0) as usize;
let px1 = ((new_ox + stride as i64).min(plane_w as i64)).max(0) as usize;
if px0 < px1 {
let dst0 = (px0 as i64 - new_ox) as usize;
self.buf[dst0..dst0 + (px1 - px0)].copy_from_slice(&strip[px0..px1]);
}
}
if capture || left.is_some() {
for (i, &v) in left_col[..ch].iter().enumerate() {
self.buf[(1 + i) * stride] = v;
}
}
self.bg_top.clear();
self.bg_top.extend_from_slice(&self.buf[..stride]);
self.bg_left.clear();
self.bg_left
.extend((0..rows).map(|cy| self.buf[cy * stride]));
}
fn clear_to_background(&mut self) {
if self.stride == 0 {
return;
}
for v in self.buf.iter_mut() {
*v = UNINIT_SAMPLE;
}
self.buf[..self.stride].copy_from_slice(&self.bg_top);
for (cy, &v) in self.bg_left.iter().enumerate() {
self.buf[cy * self.stride] = v;
}
}
}
struct JournalEntry {
c_idx: u8,
x: u32,
y: u32,
width: u32,
height: u32,
old: Vec<u16>,
}
pub(super) type CanvasSaved = Vec<RedoPatch>;
pub(super) struct RedoPatch {
c_idx: u8,
x: u32,
y: u32,
width: u32,
height: u32,
samples: Vec<u16>,
}
#[derive(Default)]
pub(in crate::encoder) struct CanvasOverlay {
planes: [CanvasPlane; 3],
n_comp: usize,
journal: Vec<JournalEntry>,
}
impl CanvasOverlay {
fn rect_copy(
plane: &mut CanvasPlane,
x: u32,
y: u32,
w: u32,
h: u32,
data: &mut [u16],
to_canvas: bool,
) {
let (cx, cy) = plane
.coords(x, y)
.expect("canvas rect outside canvas bounds");
debug_assert!(cx + w as usize <= plane.stride && cy + h as usize <= plane.rows);
for row in 0..h as usize {
let off = (cy + row) * plane.stride + cx;
let line = &mut data[row * w as usize..(row + 1) * w as usize];
if to_canvas {
plane.buf[off..off + w as usize].copy_from_slice(line);
} else {
line.copy_from_slice(&plane.buf[off..off + w as usize]);
}
}
}
fn write_rect_from_slice(
plane: &mut CanvasPlane,
x: u32,
y: u32,
width: u32,
height: u32,
data: &[u16],
) {
debug_assert_eq!(data.len(), (width * height) as usize);
let (cx, cy) = plane
.coords(x, y)
.expect("canvas rect outside canvas bounds");
debug_assert!(cx + width as usize <= plane.stride && cy + height as usize <= plane.rows);
for row in 0..height as usize {
let off = (cy + row) * plane.stride + cx;
let line = &data[row * width as usize..(row + 1) * width as usize];
plane.buf[off..off + width as usize].copy_from_slice(line);
}
}
fn push_rect(&mut self, c_idx: u8, x: u32, y: u32, width: u32, height: u32) -> usize {
let mut old = vec![0u16; (width * height) as usize];
Self::rect_copy(
&mut self.planes[c_idx as usize],
x,
y,
width,
height,
&mut old,
false,
);
self.journal.push(JournalEntry {
c_idx,
x,
y,
width,
height,
old,
});
self.journal.len() - 1
}
}
impl CanvasOverlay {
pub(super) fn reset_from_ctu(&mut self, frame: &DecodedFrame, x0: u32, y0: u32) {
self.n_comp = if frame.chroma_format == 0 { 1 } else { 3 };
for c_idx in 0..self.n_comp {
self.planes[c_idx].reset(frame, c_idx as u8, x0, y0);
}
self.journal.clear();
}
pub(super) fn reset_from_strips(
&mut self,
strips: &RowStrips,
left: Option<&LeftCols>,
chroma_format: u8,
x0: u32,
y0: u32,
) {
self.n_comp = strips.n_comp;
for c_idx in 0..self.n_comp {
self.planes[c_idx].reset_from_strip(
&strips.rows[c_idx],
strips.heights[c_idx],
left.map(|l| l.cols[c_idx].as_slice()),
chroma_format,
c_idx as u8,
x0,
y0,
);
}
self.journal.clear();
}
pub(super) fn clear(&mut self) {
for plane in self.planes[..self.n_comp].iter_mut() {
plane.clear_to_background();
}
self.journal.clear();
}
pub(super) fn sample(&self, c_idx: u8, x: u32, y: u32) -> Option<u16> {
let plane = &self.planes[c_idx as usize];
plane
.coords(x, y)
.map(|(cx, cy)| plane.buf[cy * plane.stride + cx])
}
pub(super) fn overlay_row_samples(&self, c_idx: u8, y: u32, x0: u32, dst: &mut [u16]) {
let plane = &self.planes[c_idx as usize];
for (i, sample) in dst.iter_mut().enumerate() {
if let Some((cx, cy)) = plane.coords(x0 + i as u32, y) {
*sample = plane.buf[cy * plane.stride + cx];
}
}
}
pub(super) fn overlay_col_samples(&self, c_idx: u8, x: u32, y0: u32, dst: &mut [u16]) {
let plane = &self.planes[c_idx as usize];
for (i, sample) in dst.iter_mut().enumerate() {
if let Some((cx, cy)) = plane.coords(x, y0 + i as u32) {
*sample = plane.buf[cy * plane.stride + cx];
}
}
}
pub(super) fn read_row_merged(&self, c_idx: u8, y: u32, x0: u32, dst: &mut [u16]) -> bool {
let plane = &self.planes[c_idx as usize];
let Some((cx, cy)) = plane.coords(x0, y) else {
return false;
};
if cx + dst.len() > plane.stride {
return false;
}
let off = cy * plane.stride + cx;
dst.copy_from_slice(&plane.buf[off..off + dst.len()]);
true
}
pub(super) fn read_col_merged(&self, c_idx: u8, x: u32, y0: u32, dst: &mut [u16]) -> bool {
let plane = &self.planes[c_idx as usize];
let Some((cx, cy)) = plane.coords(x, y0) else {
return false;
};
if cy + dst.len() > plane.rows {
return false;
}
for (i, sample) in dst.iter_mut().enumerate() {
*sample = plane.buf[(cy + i) * plane.stride + cx];
}
true
}
pub(super) fn push_block(
&mut self,
c_idx: u8,
x: u32,
y: u32,
width: u32,
height: u32,
samples: &[u16],
) {
debug_assert_eq!(samples.len(), (width * height) as usize);
self.push_rect(c_idx, x, y, width, height);
Self::write_rect_from_slice(
&mut self.planes[c_idx as usize],
x,
y,
width,
height,
samples,
);
}
pub(super) fn push_block_u8(
&mut self,
c_idx: u8,
x: u32,
y: u32,
width: u32,
height: u32,
samples: &[u8],
) {
debug_assert_eq!(samples.len(), (width * height) as usize);
self.push_rect(c_idx, x, y, width, height);
let plane = &mut self.planes[c_idx as usize];
let (cx, cy) = plane
.coords(x, y)
.expect("canvas rect outside canvas bounds");
for row in 0..height as usize {
let off = (cy + row) * plane.stride + cx;
let src = &samples[row * width as usize..(row + 1) * width as usize];
for (dst, &s) in plane.buf[off..off + width as usize].iter_mut().zip(src) {
*dst = u16::from(s);
}
}
}
pub(super) fn mark(&self) -> usize {
self.journal.len()
}
pub(super) fn truncate(&mut self, mark: usize) {
while self.journal.len() > mark {
let mut e = self.journal.pop().unwrap();
Self::rect_copy(
&mut self.planes[e.c_idx as usize],
e.x,
e.y,
e.width,
e.height,
&mut e.old,
true,
);
}
}
pub(super) fn detach_from(&mut self, mark: usize) -> CanvasSaved {
let mut redo: Vec<RedoPatch> = Vec::with_capacity(self.journal.len().saturating_sub(mark));
while self.journal.len() > mark {
let mut e = self.journal.pop().unwrap();
let mut samples = vec![0u16; (e.width * e.height) as usize];
Self::rect_copy(
&mut self.planes[e.c_idx as usize],
e.x,
e.y,
e.width,
e.height,
&mut samples,
false,
);
Self::rect_copy(
&mut self.planes[e.c_idx as usize],
e.x,
e.y,
e.width,
e.height,
&mut e.old,
true,
);
redo.push(RedoPatch {
c_idx: e.c_idx,
x: e.x,
y: e.y,
width: e.width,
height: e.height,
samples,
});
}
redo.reverse();
redo
}
pub(super) fn reattach(&mut self, saved: CanvasSaved) {
for patch in saved {
let mut old = vec![0u16; (patch.width * patch.height) as usize];
Self::rect_copy(
&mut self.planes[patch.c_idx as usize],
patch.x,
patch.y,
patch.width,
patch.height,
&mut old,
false,
);
self.journal.push(JournalEntry {
c_idx: patch.c_idx,
x: patch.x,
y: patch.y,
width: patch.width,
height: patch.height,
old,
});
Self::write_rect_from_slice(
&mut self.planes[patch.c_idx as usize],
patch.x,
patch.y,
patch.width,
patch.height,
&patch.samples,
);
}
}
pub(in crate::encoder) fn for_each_ctu_row(
&self,
c_idx: u8,
plane_w: usize,
plane_h: usize,
mut f: impl FnMut(usize, usize, &[u16]),
) {
let plane = &self.planes[c_idx as usize];
if plane.stride == 0 {
return;
}
let ctu_w = (plane.stride - 1) / 2;
let ctu_h = (plane.rows - 1) / 2;
let px0 = plane.origin_x + 1;
let py0 = plane.origin_y + 1;
let px1 = (px0 + ctu_w as i64).min(plane_w as i64);
let py1 = (py0 + ctu_h as i64).min(plane_h as i64);
for py in py0..py1 {
let cy = (py - plane.origin_y) as usize;
let cx0 = (px0 - plane.origin_x) as usize;
let n = (px1 - px0) as usize;
let off = cy * plane.stride + cx0;
f(py as usize, px0 as usize, &plane.buf[off..off + n]);
}
}
pub(super) fn commit_to_frame(&self, frame: &mut DecodedFrame) {
for c_idx in 0..self.n_comp {
let plane = &self.planes[c_idx];
let (dst, pstride) = frame.plane_mut(c_idx as u8);
let plane_h = if pstride == 0 { 0 } else { dst.len() / pstride };
let ctu_w = (plane.stride - 1) / 2;
let ctu_h = (plane.rows - 1) / 2;
let px0 = plane.origin_x + 1;
let py0 = plane.origin_y + 1;
let px1 = (px0 + ctu_w as i64).min(pstride as i64);
let py1 = (py0 + ctu_h as i64).min(plane_h as i64);
for py in py0..py1 {
let cy = (py - plane.origin_y) as usize;
let cx0 = (px0 - plane.origin_x) as usize;
let n = (px1 - px0) as usize;
let src = &plane.buf[cy * plane.stride + cx0..cy * plane.stride + cx0 + n];
dst[py as usize * pstride + px0 as usize..py as usize * pstride + px0 as usize + n]
.copy_from_slice(src);
}
}
}
}
pub(in crate::encoder) struct RowStrips {
rows: [Vec<u16>; 3],
heights: [usize; 3],
n_comp: usize,
}
impl RowStrips {
pub(in crate::encoder) fn new(frame: &DecodedFrame) -> Self {
let n_comp = if frame.chroma_format == 0 { 1 } else { 3 };
let mut rows: [Vec<u16>; 3] = Default::default();
let mut heights = [0usize; 3];
for (c, (row, height)) in rows
.iter_mut()
.zip(heights.iter_mut())
.enumerate()
.take(n_comp)
{
let (w, h) = frame.component_dims(c as u8);
*row = vec![UNINIT_SAMPLE; w as usize];
*height = h as usize;
}
Self {
rows,
heights,
n_comp,
}
}
pub(in crate::encoder) fn clear(&mut self) {
for row in self.rows[..self.n_comp].iter_mut() {
row.fill(UNINIT_SAMPLE);
}
}
pub(in crate::encoder) fn row_mut(&mut self, c_idx: usize) -> &mut [u16] {
&mut self.rows[c_idx]
}
}
#[derive(Default)]
pub(in crate::encoder) struct LeftCols {
cols: [Vec<u16>; 3],
}
impl LeftCols {
pub(in crate::encoder) fn col_mut(&mut self, c_idx: usize, len: usize) -> &mut [u16] {
let col = &mut self.cols[c_idx];
col.clear();
col.resize(len, UNINIT_SAMPLE);
col
}
}
pub(in crate::encoder) enum ReconBackground<'a> {
Frame,
Strips {
strips: &'a RowStrips,
left: Option<&'a LeftCols>,
},
}