--- /dev/null
+use super::CB_SELECTORS;
+use super::mv::MV;
+use super::super::indeo3data::*;
+use super::{Indeo3Cell, Plane};
+
+pub const MAX_CELL_SIZE: usize = 2400;
+const DEFAULT_PIXEL: u8 = 0x40;
+const INTRA_FLAT_THRESHOLD: u32 = 8;
+const INTER_FLAT_THRESHOLD: u32 = 8;
+
+struct IndexWriter<'a> {
+ dst: &'a mut [u8],
+ pos: usize,
+ do_rle: bool,
+}
+
+const SKIP_CELL: u8 = 0xFD;
+const ZERO_CELL: u8 = 0xFD;
+
+impl<'a> IndexWriter<'a> {
+ fn new(dst: &'a mut [u8], do_rle: bool) -> Self {
+ Self {
+ dst,
+ pos: 0,
+ do_rle,
+ }
+ }
+ fn write_pair(&mut self, idx0: u8, idx1: u8, quad_radix: u8, esc: u8) {
+ //xxx: in theory one in theory the other index just has to make output fit byte range
+ if idx0 < quad_radix && idx1 < quad_radix {
+ let quad = idx1 * quad_radix + idx0 + esc;
+ self.dst[self.pos] = quad;
+ self.pos += 1;
+ } else {
+ self.dst[self.pos] = idx0;
+ self.pos += 1;
+ self.dst[self.pos] = idx1;
+ self.pos += 1;
+ }
+ }
+ fn write_byte(&mut self, val: u8) {
+ self.dst[self.pos] = val;
+ self.pos += 1;
+ }
+ fn compact_cell(&mut self, esc_vals: [u8; 4]) {
+ if !self.do_rle {
+ return;
+ }
+ let tail = &self.dst[self.pos - 4..][..4];
+ let mut count = 0;
+ for (&a, &b) in tail.iter().zip(esc_vals.iter()).rev() {
+ if a != b {
+ break;
+ }
+ count += 1;
+ }
+ if count > 1 {
+ self.pos -= count;
+ self.dst[self.pos] = ZERO_CELL;
+ self.pos += 1;
+ }
+ }
+ fn compact_all_cells(&mut self) {
+ if !self.do_rle {
+ return;
+ }
+ if self.pos > 2 {
+ let mut i = 0;
+ while i + 2 < self.pos {
+ if self.dst[i] == ZERO_CELL && self.dst[i + 1] == ZERO_CELL {
+ let mut last_idx = i;
+ for j in (i + 1)..self.pos {
+ if self.dst[j] != ZERO_CELL {
+ break;
+ }
+ last_idx = j;
+ }
+ let len = (last_idx - i + 1).min(31);
+ if len == 2 {
+ self.dst[i] = 0xFC;
+ move_tail(&mut self.dst[i + 1..self.pos], 1);
+ self.pos -= 1;
+ } else {
+ self.dst[i] = 0xFB;
+ self.dst[i + 1] = len as u8;
+ move_tail(&mut self.dst[i + 2..self.pos], len - 2);
+ self.pos -= len - 2;
+ }
+ }
+ i += 1;
+ }
+ }
+ }
+ fn end(self) -> usize {
+ self.pos
+ }
+}
+
+fn move_tail(buf: &mut [u8], off: usize) {
+ let len = buf.len();
+ for i in off..len {
+ buf[i - off] = buf[i];
+ }
+}
+
+#[derive(Default)]
+struct CodebookSuggester {
+ count: [u16; 16],
+}
+
+const BINNING_FACTORS: [u8; 16] = [3, 7, 9, 12, 14, 16, 18, 40, 2, 3, 4, 5, 6, 7, 8, 9];
+
+impl CodebookSuggester {
+ fn new() -> Self { Self::default() }
+ fn merge(cs1: &Self, cs2: &Self) -> Self {
+ let mut count = [0; 16];
+ for (dst, (&src1, &src2)) in count.iter_mut().zip(cs1.count.iter().zip(cs2.count.iter())) {
+ *dst = src1 + src2;
+ }
+ Self { count }
+ }
+ fn add_delta(&mut self, delta: u8) {
+ for (i, &fac) in BINNING_FACTORS.iter().enumerate() {
+ let val = if i < 8 { delta + fac - 1 } else { delta };
+ if (val % fac) == 0 {
+ self.count[i] += 1;
+ }
+ }
+ }
+ fn add_line(&mut self, src: &[i8]) {
+ for &delta in src.iter() {
+ if delta == 0 {
+ continue;
+ }
+ let delta = delta.abs() as u8;
+ self.add_delta(delta);
+ }
+ }
+ fn add_line_half(&mut self, src: &[i8]) {
+ for &delta in src.iter().step_by(2) {
+ if delta == 0 {
+ continue;
+ }
+ let delta = delta.abs() as u8;
+ self.add_delta(delta);
+ }
+ }
+ fn get_best(&self) -> u8 {
+ let mut idx = 0;
+ for (i, &cnt) in self.count.iter().enumerate().skip(1) {
+ if cnt > self.count[idx] {
+ idx = i;
+ }
+ }
+ idx as u8
+ }
+}
+
+pub struct CellEncoder {
+ buf: [u8; MAX_CELL_SIZE + 160],
+ rbuf: [u8; MAX_CELL_SIZE + 160],
+ deltas: [i8; MAX_CELL_SIZE],
+ cell: Indeo3Cell,
+ pub out: [u8; MAX_CELL_SIZE / 2 + 1],
+ pub osize: usize,
+
+ pub flat_thr_i: u32,
+ pub flat_thr_p: u32,
+ pub do_rle: bool,
+ pub quant: Option<u8>,
+}
+
+impl CellEncoder {
+ pub fn new() -> Self {
+ Self {
+ buf: [0; MAX_CELL_SIZE + 160],
+ rbuf: [0; MAX_CELL_SIZE + 160],
+ deltas: [0; MAX_CELL_SIZE],
+ cell: Indeo3Cell::new(0, 0, false),
+ out: [0; MAX_CELL_SIZE / 2 + 1],
+ osize: 0,
+
+ flat_thr_i: INTRA_FLAT_THRESHOLD,
+ flat_thr_p: INTER_FLAT_THRESHOLD,
+ do_rle: true,
+ quant: None,
+ }
+ }
+ pub fn read_buffer(&mut self, plane: &Plane, cell: Indeo3Cell) {
+ self.cell = cell;
+
+ let src = &plane.data[cell.get_x() + cell.get_y() * plane.width..];
+ let dst_w = cell.get_width();
+ for (dline, sline) in self.buf.chunks_mut(dst_w).skip(1).zip(src.chunks(plane.width)).take(cell.get_height()) {
+ dline.copy_from_slice(&sline[..dst_w]);
+ }
+ if cell.get_y() > 0 {
+ self.buf[..dst_w].copy_from_slice(&plane.data[cell.get_x() + (cell.get_y() - 1) * plane.width..][..dst_w]);
+ } else {
+ for el in self.buf[..dst_w].iter_mut() {
+ *el = DEFAULT_PIXEL;
+ }
+ }
+ }
+ pub fn read_mv_buffer(&mut self, plane: &Plane, cell: Indeo3Cell, mv: MV) {
+ self.cell = cell;
+
+ let xoff = (cell.get_x() as isize + isize::from(mv.x)) as usize;
+ let yoff = (cell.get_y() as isize + isize::from(mv.y)) as usize;
+ let src = &plane.data[xoff + yoff * plane.width..];
+ let dst_w = cell.get_width();
+ for (dline, sline) in self.rbuf.chunks_mut(dst_w).skip(1).zip(src.chunks(plane.width)).take(cell.get_height()) {
+ dline.copy_from_slice(&sline[..dst_w]);
+ }
+ }
+ pub fn null_mv(&mut self) {
+ let stride = self.cell.get_width();
+ self.buf[stride..].copy_from_slice(&self.rbuf[stride..]);
+ }
+ pub fn gen_diffs_intra(&mut self) {
+ let stride = self.cell.get_width();
+ let mut start = stride;
+ for dline in self.deltas.chunks_mut(stride).take(self.cell.get_height()) {
+ let (pprev, cur) = self.buf.split_at(start);
+ let prev = &pprev[pprev.len() - stride..];
+
+ for (dst, (&cur, &top)) in dline.iter_mut().zip(cur.iter().zip(prev.iter())) {
+ *dst = (cur as i8) - (top as i8);
+ }
+
+ start += stride;
+ }
+ }
+ pub fn gen_diffs_inter(&mut self) {
+ let stride = self.cell.get_width();
+ let prev_iter = self.rbuf.chunks(stride).skip(1);
+ let cur_iter = self.buf.chunks(stride).skip(1);
+ for (dline, (cur, prev)) in self.deltas.chunks_mut(stride).take(self.cell.get_height()).zip(cur_iter.zip(prev_iter)) {
+ for (dst, (&cur, &prev)) in dline.iter_mut().zip(cur.iter().zip(prev.iter())) {
+ *dst = (cur as i8) - (prev as i8);
+ }
+ }
+ }
+ pub fn put_buffer(&self, plane: &mut Plane) {
+ let to_skip = if !self.cell.is_intra() || self.cell.get_y() == 0 { 1 } else { 0 };
+
+ let dst = &mut plane.data[self.cell.get_x() + (self.cell.get_y() + to_skip - 1) * plane.width..];
+ let src_w = self.cell.get_width();
+ for (sline, dline) in self.buf.chunks(src_w).skip(to_skip).zip(dst.chunks_mut(plane.width)).take(self.cell.get_height() + 1 - to_skip) {
+ dline[..src_w].copy_from_slice(sline);
+ }
+ }
+ fn determine_mode(&self, intra: bool, mut mode_hint: u8) -> (u8, [u8; 2]) {
+ if let Some(qmode) = self.quant {
+ if intra {
+ return (mode_hint, [qmode as u8, qmode as u8]);
+ } else {
+ let qmode = (qmode & 7) as u8;
+ return (mode_hint, [qmode, qmode]);
+ }
+ }
+
+ let stride = self.cell.get_width();
+
+ let mut cb_p = CodebookSuggester::new();
+ let mut cb_s = CodebookSuggester::new();
+ if !intra && (self.cell.get_height() & 7 == 0) {
+ let mut vdiff = 0;
+ let mut hdiff = 0;
+ for line_pair in self.deltas.chunks(stride * 2).take(self.cell.get_height() / 2) {
+ let (line1, line2) = line_pair.split_at(stride);
+ for (&el1, &el2) in line1.iter().zip(line2.iter()) {
+ let diff = i32::from(el1) - i32::from(el2);
+ vdiff += (diff * diff) as u32;
+ }
+ }
+ for line in self.deltas.chunks(stride).take(self.cell.get_height()) {
+ for pair in line.chunks(2) {
+ let diff = i32::from(pair[1]) - i32::from(pair[0]);
+ hdiff += (diff * diff) as u32;
+ }
+ }
+ vdiff /= (self.cell.get_width() * self.cell.get_height() / 2) as u32;
+ hdiff /= (self.cell.get_width() * self.cell.get_height() / 2) as u32;
+
+ mode_hint = match ((vdiff > self.flat_thr_p), (hdiff > self.flat_thr_p)) {
+ (false, false) if (self.cell.get_width() & 7) == 0 => 10,
+ (false, _) => 11,
+ _ => 0,
+ };
+ }
+ match mode_hint {
+ 0 => {
+ for line_pair in self.deltas.chunks(stride * 2).take(self.cell.get_height() / 2) {
+ let (line1, line2) = line_pair.split_at(stride);
+ cb_p.add_line(line1);
+ cb_s.add_line(line2);
+ }
+ },
+ 3 => {
+ for line_quad in self.deltas.chunks(stride * 4).take(self.cell.get_height() / 4) {
+ let (line01, line23) = line_quad.split_at(stride * 2);
+ let (_line0, line1) = line01.split_at(stride);
+ let (_line2, line3) = line23.split_at(stride);
+ cb_p.add_line(line1);
+ cb_s.add_line(line3);
+ }
+ },
+ 10 => {
+ for line_quad in self.deltas.chunks(stride * 4).take(self.cell.get_height() / 4) {
+ let (line01, line23) = line_quad.split_at(stride * 2);
+ let (_line0, line1) = line01.split_at(stride);
+ let (_line2, line3) = line23.split_at(stride);
+ cb_p.add_line_half(line1);
+ cb_s.add_line_half(line3);
+ }
+ },
+ 11 => {
+ for line_quad in self.deltas.chunks(stride * 4).take(self.cell.get_height() / 4) {
+ let (line01, line23) = line_quad.split_at(stride * 2);
+ let (_line0, line1) = line01.split_at(stride);
+ let (_line2, line3) = line23.split_at(stride);
+ cb_p.add_line(line1);
+ cb_s.add_line(line3);
+ }
+ },
+ _ => unreachable!(),
+ };
+ let cb_f = CodebookSuggester::merge(&cb_p, &cb_s).get_best();
+ let cb_p = cb_p.get_best();
+ let mut cb_s = cb_s.get_best();
+
+ let mut use_single = !intra || mode_hint == 10 || cb_p == cb_s;
+ if !use_single {
+ if cb_s == 0 { // we can adjust to the CB_SELECTORS here
+ cb_s = (((cb_p & 7) + 1) * 2).min(15);
+ }
+ let ncb = (cb_p << 4) + cb_s;
+ use_single = !CB_SELECTORS.contains(&ncb);
+ }
+
+ if use_single {
+ if intra || cb_f < 8 { // we don't want requant happening in inter mode
+ (mode_hint, [cb_f, cb_f])
+ } else {
+ (mode_hint, [0, 0])
+ }
+ } else {
+ (mode_hint + 1, [cb_p, cb_s])
+ }
+ }
+ pub fn compress_intra(&mut self, mode_hint: u8) {
+ let (mode, vq_idx) = self.determine_mode(true, mode_hint);
+
+ let cb_no1 = usize::from(vq_idx[1]);
+ let cb_no2 = usize::from(vq_idx[0]);
+ let cb1 = IVI3_DELTA_CBS[cb_no1];
+ let cb2 = IVI3_DELTA_CBS[cb_no2];
+
+ let mut requant_idx = None;
+ if (mode == 1) || (mode == 4) {
+ let aq_idx = (vq_idx[0] << 4) | vq_idx[1];
+ let mut idx = 42;
+ for (i, &el) in CB_SELECTORS.iter().enumerate() {
+ if el == aq_idx {
+ idx = i;
+ break;
+ }
+ }
+ self.out[0] = (mode << 4) | (idx as u8);
+
+ if idx >= 8 {
+ requant_idx = Some(idx - 8);
+ }
+ } else {
+ self.out[0] = (mode << 4) | (cb_no1 as u8);
+
+ if (8..=15).contains(&cb_no1) {
+ requant_idx = Some(cb_no1 - 8);
+ }
+ }
+ if self.cell.get_y() == 0 {
+ requant_idx = None;
+ }
+
+ let start = 1;
+ let mut iwriter = IndexWriter::new(&mut self.out[start..], self.do_rle);
+
+ let esc_val1 = (cb1.data.len() / 2) as u8;
+ let esc_val2 = (cb2.data.len() / 2) as u8;
+
+ let cbs = [cb1, cb2, cb1, cb2];
+ let esc_vals = [esc_val1, esc_val2, esc_val1, esc_val2];
+
+ let mut first_line = self.cell.get_y() == 0;
+ let stride = self.cell.get_width();
+
+ if let Some(ridx) = requant_idx {// && !first_line {
+ requant(&mut self.buf[..stride], ridx);
+ }
+
+ let mut cell4 = [0; 20];
+ match mode {
+ 0 | 1 | 2 => {
+ for y in (0..self.cell.get_height()).step_by(4) {
+ for x in (0..self.cell.get_width()).step_by(4) {
+ Self::get_cell4(&self.buf, x, y, stride, &mut cell4);
+ // first check if the cell can be coded with zero predictor
+ let mut diff = 0;
+ let mut pivot = 4;
+ for _y in 0..4 {
+ let (top, cur) = cell4.split_at(pivot);
+ let top = &top[top.len() - 4..];
+ for (&tval, &cval) in top.iter().zip(cur.iter()) {
+ let cdiff = i32::from(tval) - i32::from(cval);
+ diff += cdiff * cdiff;
+ }
+ pivot += 4;
+ }
+ if (diff as u32) < self.flat_thr_i {
+ iwriter.write_byte(ZERO_CELL);
+ let (top, tail) = cell4.split_at_mut(4);
+ for dline in tail.chunks_mut(4) {
+ dline.copy_from_slice(top);
+ }
+ Self::put_cell4(&mut self.buf, x, y, stride, &cell4);
+ continue;
+ }
+
+ compress_intra_cell(&mut iwriter, &mut cell4, &cbs, esc_vals);
+ Self::put_cell4(&mut self.buf, x, y, stride, &cell4);
+ }
+ }
+ },
+ 3 | 4 => {
+ for y in (0..self.cell.get_height()).step_by(8) {
+ for x in (0..self.cell.get_width()).step_by(4) {
+ Self::get_cell_mode3(&self.buf, x, y, stride, &mut cell4);
+ compress_intra_cell(&mut iwriter, &mut cell4, &cbs, esc_vals);
+ Self::put_cell_mode3(&mut self.buf, x, y, stride, &cell4, first_line);
+ }
+ first_line = false;
+ }
+ },
+ 10 => {
+ for y in (0..self.cell.get_height()).step_by(8) {
+ for x in (0..self.cell.get_width()).step_by(8) {
+ Self::get_cell_mode10i(&self.buf, x, y, stride, &mut cell4);
+ compress_intra_cell(&mut iwriter, &mut cell4, &cbs, esc_vals);
+ Self::put_cell_mode10i(&mut self.buf, x, y, stride, &cell4, first_line);
+ }
+ first_line = false;
+ }
+ },
+ _ => unreachable!(),
+ };
+ iwriter.compact_all_cells();
+
+ self.osize = iwriter.end() + start;
+ }
+ pub fn compress_inter(&mut self) {
+ let (mode, vq_idx) = self.determine_mode(false, 0);
+
+ let cb_no1 = usize::from(vq_idx[1]);
+ let cb_no2 = usize::from(vq_idx[0]);
+ let cb1 = IVI3_DELTA_CBS[cb_no1];
+ let cb2 = IVI3_DELTA_CBS[cb_no2];
+
+ if (mode == 1) || (mode == 4) {
+ let aq_idx = (vq_idx[0] << 4) | vq_idx[1];
+ let mut idx = 42;
+ for (i, &el) in CB_SELECTORS.iter().enumerate() {
+ if el == aq_idx {
+ idx = i;
+ break;
+ }
+ }
+ self.out[0] = (mode << 4) | (idx as u8);
+ } else {
+ self.out[0] = (mode << 4) | (cb_no1 as u8);
+ }
+ let start = 1;
+ let mut iwriter = IndexWriter::new(&mut self.out[start..], self.do_rle);
+
+ let esc_val1 = (cb1.data.len() / 2) as u8;
+ let esc_val2 = (cb2.data.len() / 2) as u8;
+
+ let cbs = [cb1, cb2, cb1, cb2];
+ let esc_vals = [esc_val1, esc_val2, esc_val1, esc_val2];
+
+
+ let stride = self.cell.get_width();
+ let mut ccell4 = [0; 20];
+ let mut pcell4 = [0; 20];
+ match mode {
+ 0 | 1 | 2 => {
+ for y in (0..self.cell.get_height()).step_by(4) {
+ for x in (0..self.cell.get_width()).step_by(4) {
+ Self::get_cell4(&self.buf, x, y, stride, &mut ccell4);
+ Self::get_cell4(&self.rbuf, x, y, stride, &mut pcell4);
+ // first check if the cell can be coded with zero predictor
+ let mut diff = 0;
+ for (&pval, &cval) in pcell4[4..].iter().zip(ccell4[4..].iter()) {
+ let cdiff = i32::from(pval) - i32::from(cval);
+ diff += cdiff * cdiff;
+ }
+ if diff < 8 {
+ iwriter.write_byte(SKIP_CELL);
+ Self::put_cell4(&mut self.buf, x, y, stride, &pcell4);
+ continue;
+ }
+
+ compress_inter_cell(&mut iwriter, &mut ccell4, &pcell4, &cbs, esc_vals);
+ Self::put_cell4(&mut self.buf, x, y, stride, &ccell4);
+ }
+ }
+ },
+ 10 => {
+ let mut offset = 0;
+ let mut ref_cell = [0; 64];
+ let mut avg_diff: [i16; 16];
+ for _y in (0..self.cell.get_height()).step_by(8) {
+ for x in (0..self.cell.get_width()).step_by(8) {
+ for (dline, sline) in ref_cell.chunks_mut(8).zip(self.rbuf[offset + stride + x..].chunks(stride)) {
+ dline.copy_from_slice(&sline[..8]);
+ }
+ avg_diff = [0; 16];
+ for j in 0..8 {
+ for i in 0..8 {
+ avg_diff[i / 2 + (j / 2) * 4] += i16::from(self.deltas[offset + x + i + j * stride]);
+ }
+ }
+ for el in avg_diff.iter_mut() {
+ *el = (*el + 2) >> 2;
+ }
+ compress_inter_cell_mode10(&mut iwriter, &mut ref_cell, &avg_diff, &cbs, esc_vals);
+ for (sline, dline) in ref_cell.chunks(8).zip(self.buf[offset + stride + x..].chunks_mut(stride)) {
+ dline[..8].copy_from_slice(sline);
+ }
+ }
+ offset += stride * 8;
+ }
+ },
+ 11 => {
+ let mut offset = 0;
+ let mut ref_cell = [0; 32];
+ let mut avg_diff: [i16; 16];
+ for _y in (0..self.cell.get_height()).step_by(8) {
+ for x in (0..self.cell.get_width()).step_by(4) {
+ for (dline, sline) in ref_cell.chunks_mut(4).zip(self.rbuf[offset + stride + x..].chunks(stride)) {
+ dline.copy_from_slice(&sline[..4]);
+ }
+ avg_diff = [0; 16];
+ for j in 0..8 {
+ for i in 0..4 {
+ avg_diff[i + (j / 2) * 4] += i16::from(self.deltas[offset + x + i + j * stride]);
+ }
+ }
+ for el in avg_diff.iter_mut() {
+ *el = (*el + 1) >> 1;
+ }
+
+ compress_inter_cell_mode11(&mut iwriter, &mut ref_cell, &avg_diff, &cbs, esc_vals);
+ for (sline, dline) in ref_cell.chunks(4).zip(self.buf[offset + stride + x..].chunks_mut(stride)) {
+ dline[..4].copy_from_slice(sline);
+ }
+ }
+ offset += stride * 8;
+ }
+ },
+ _ => unreachable!(),
+ };
+ iwriter.compact_all_cells();
+
+ self.osize = iwriter.end() + start;
+ }
+
+ fn get_cell4(data: &[u8], x: usize, y: usize, stride: usize, cell: &mut [u8; 20]) {
+ for (dst, src) in cell.chunks_mut(4).zip(data[x + y * stride..].chunks(stride)) {
+ dst.copy_from_slice(&src[..4]);
+ }
+ }
+ fn put_cell4(data: &mut [u8], x: usize, y: usize, stride: usize, cell: &[u8; 20]) {
+ for (src, dst) in cell.chunks(4).zip(data[x + y * stride..].chunks_mut(stride)).skip(1) {
+ dst[..4].copy_from_slice(src);
+ }
+ }
+ fn get_cell_mode3(data: &[u8], x: usize, y: usize, stride: usize, cell: &mut [u8; 20]) {
+ let src = &data[x + y * stride..];
+ for (dline, slines) in cell.chunks_mut(4).zip(src.chunks(stride * 2)) {
+ dline.copy_from_slice(&slines[..4]);
+ }
+ }
+ fn put_cell_mode3(data: &mut [u8], x: usize, y: usize, stride: usize, cell: &[u8; 20], first_line: bool) {
+ let dst = &mut data[x + y * stride..];
+ let mut dst_idx = stride;
+ for line in 0..4 {
+ for x in 0..4 {
+ let top = cell[line * 4 + x];
+ let cur = cell[(line + 1) * 4 + x];
+ dst[dst_idx + x] = (top + cur) >> 1;
+ dst[dst_idx + stride + x] = cur;
+ }
+ dst_idx += stride * 2;
+ }
+ if first_line {
+ dst[stride..][..4].copy_from_slice(&cell[4..8]);
+ }
+ }
+ fn get_cell_mode10i(data: &[u8], x: usize, y: usize, stride: usize, cell: &mut [u8; 20]) {
+ let src = &data[x + y * stride..];
+ for (dline, src_pair) in cell.chunks_mut(4).zip(src.chunks(stride * 2)) {
+ for (dst, src) in dline.iter_mut().zip(src_pair.chunks(2)) {
+ *dst = src[0];
+ }
+ }
+ }
+ fn put_cell_mode10i(data: &mut [u8], x: usize, y: usize, stride: usize, cell: &[u8; 20], first_line: bool) {
+ let dst = &mut data[x + y * stride..];
+ let mut dst_idx = stride;
+ for line in 0..4 {
+ for x in 0..4 {
+ let top = dst[dst_idx - stride + x * 2];
+ let cur = cell[(line + 1) * 4 + x];
+ dst[dst_idx + x * 2] = (top + cur) >> 1;
+ dst[dst_idx + x * 2 + 1] = (top + cur) >> 1;
+ dst[dst_idx + stride + x * 2] = cur;
+ dst[dst_idx + stride + x * 2 + 1] = cur;
+ }
+ dst_idx += stride * 2;
+ }
+ if first_line {
+ let (top, tail) = dst[stride..].split_at_mut(stride);
+ top[..8].copy_from_slice(&tail[..8]);
+ }
+ }
+}
+
+fn requant(line: &mut [u8], rq_index: usize) {
+ let tab = &REQUANT_TAB[rq_index];
+ for el in line.iter_mut() {
+ *el = tab[usize::from(*el)];
+ }
+}
+
+fn compress_intra_cell(iwriter: &mut IndexWriter, cell4: &mut [u8; 20], cbs: &[&IviDeltaCB; 4], esc_vals: [u8; 4]) {
+ let mut pivot = 4;
+ for y in 0..4 {
+ let cb = cbs[y];
+ let esc_val = esc_vals[y];
+
+ let (prev, cur) = cell4.split_at_mut(pivot);
+ let prev = &prev[prev.len() - 4..];
+ let cur = &mut cur[..4];
+ let (idx0, idx1) = find_quad(&cb.data, prev, cur);
+
+ cur[0] = ((prev[0] as i8) + cb.data[usize::from(idx1) * 2]) as u8;
+ cur[1] = ((prev[1] as i8) + cb.data[usize::from(idx1) * 2 + 1]) as u8;
+ cur[2] = ((prev[2] as i8) + cb.data[usize::from(idx0) * 2]) as u8;
+ cur[3] = ((prev[3] as i8) + cb.data[usize::from(idx0) * 2 + 1]) as u8;
+
+ iwriter.write_pair(idx0, idx1, cb.quad_radix, esc_val);
+
+ pivot += 4;
+ }
+ iwriter.compact_cell(esc_vals);
+}
+
+fn compress_inter_cell(iwriter: &mut IndexWriter, ccell4: &mut [u8; 20], pcell: &[u8; 20], cbs: &[&IviDeltaCB; 4], esc_vals: [u8; 4]) {
+ for (y, (prev, cur)) in pcell[4..].chunks(4).zip(ccell4[4..].chunks_mut(4)).enumerate() {
+ let cb = cbs[y];
+ let esc_val = esc_vals[y];
+
+ let (idx0, idx1) = find_quad(&cb.data, prev, cur);
+
+ cur[0] = ((prev[0] as i8) + cb.data[usize::from(idx1) * 2]) as u8;
+ cur[1] = ((prev[1] as i8) + cb.data[usize::from(idx1) * 2 + 1]) as u8;
+ cur[2] = ((prev[2] as i8) + cb.data[usize::from(idx0) * 2]) as u8;
+ cur[3] = ((prev[3] as i8) + cb.data[usize::from(idx0) * 2 + 1]) as u8;
+
+ iwriter.write_pair(idx0, idx1, cb.quad_radix, esc_val);
+ }
+ iwriter.compact_cell(esc_vals);
+}
+
+fn compress_inter_cell_mode10(iwriter: &mut IndexWriter, cell: &mut [u8; 64], diffs: &[i16; 16], cbs: &[&IviDeltaCB; 4], esc_vals: [u8; 4]) {
+ for y in 0..4 {
+ let cb = cbs[y];
+ let esc_val = esc_vals[y];
+ let mut indices = [0, 0];
+ for pair_no in (0..4).step_by(2) {
+ let src_idx = y * 8 * 2 + pair_no * 2;
+ let src0 = [cell[src_idx], cell[src_idx + 1], cell[src_idx + 8], cell[src_idx + 9]];
+ let src1 = [cell[src_idx + 2], cell[src_idx + 3], cell[src_idx + 10], cell[src_idx + 11]];
+
+ let cur_diff = [diffs[y * 4 + pair_no] as i8, diffs[y * 4 + pair_no + 1] as i8];
+
+ let mut best_idx = 0;
+ let mut best_dist = pair_dist(&cur_diff, &[0, 0]);
+ for (idx, cbpair) in cb.data.chunks(2).enumerate().skip(1) {
+ let dist = pair_dist(&cur_diff, cbpair);
+ if dist < best_dist {
+ let mut fits = true;
+ for &el in src0.iter() {
+ if !in_range(el as i8, cbpair[0]) {
+ fits = false;
+ break;
+ }
+ }
+ for &el in src1.iter() {
+ if !in_range(el as i8, cbpair[1]) {
+ fits = false;
+ break;
+ }
+ }
+ if fits {
+ best_dist = dist;
+ best_idx = idx;
+ }
+ }
+ }
+
+ indices[pair_no / 2] = best_idx as u8;
+
+ let cb_pair = &cb.data[best_idx * 2..];
+ for row in cell[src_idx..].chunks_mut(8).take(2) {
+ row[0] = ((row[0] as i8) + cb_pair[0]) as u8;
+ row[1] = ((row[1] as i8) + cb_pair[0]) as u8;
+ row[2] = ((row[2] as i8) + cb_pair[1]) as u8;
+ row[3] = ((row[3] as i8) + cb_pair[1]) as u8;
+ }
+ }
+ iwriter.write_pair(indices[1], indices[0], cb.quad_radix, esc_val);
+ }
+ iwriter.compact_cell(esc_vals);
+}
+
+fn compress_inter_cell_mode11(iwriter: &mut IndexWriter, cell: &mut [u8; 32], diffs: &[i16; 16], cbs: &[&IviDeltaCB; 4], esc_vals: [u8; 4]) {
+ for y in 0..4 {
+ let cb = cbs[y];
+ let esc_val = esc_vals[y];
+ let mut indices = [0, 0];
+ for pair_no in (0..4).step_by(2) {
+ let src_idx = y * 4 * 2 + pair_no;
+ let src0 = [cell[src_idx], cell[src_idx + 4]];
+ let src1 = [cell[src_idx + 1], cell[src_idx + 5]];
+
+ let cur_diff = [diffs[y * 4 + pair_no] as i8, diffs[y * 4 + pair_no + 1] as i8];
+
+ let mut best_idx = 0;
+ let mut best_dist = pair_dist(&cur_diff, &[0, 0]);
+ for (idx, cbpair) in cb.data.chunks(2).enumerate().skip(1) {
+ let dist = pair_dist(&cur_diff, cbpair);
+ if dist < best_dist {
+ let mut fits = true;
+ for &el in src0.iter() {
+ if !in_range(el as i8, cbpair[0]) {
+ fits = false;
+ break;
+ }
+ }
+ for &el in src1.iter() {
+ if !in_range(el as i8, cbpair[1]) {
+ fits = false;
+ break;
+ }
+ }
+ if fits {
+ best_dist = dist;
+ best_idx = idx;
+ }
+ }
+ }
+
+ indices[pair_no / 2] = best_idx as u8;
+
+ let cb_pair = &cb.data[best_idx * 2..];
+ cell[src_idx] = ((cell[src_idx] as i8) + cb_pair[0]) as u8;
+ cell[src_idx + 4] = ((cell[src_idx + 4] as i8) + cb_pair[0]) as u8;
+ cell[src_idx + 1] = ((cell[src_idx + 1] as i8) + cb_pair[1]) as u8;
+ cell[src_idx + 5] = ((cell[src_idx + 5] as i8) + cb_pair[1]) as u8;
+ }
+ iwriter.write_pair(indices[1], indices[0], cb.quad_radix, esc_val);
+ }
+ iwriter.compact_cell(esc_vals);
+}
+
+fn pair_dist(src: &[i8], pair: &[i8]) -> u32 {
+ let d0 = (i32::from(src[0]) - i32::from(pair[0])).abs() as u32;
+ let d1 = (i32::from(src[1]) - i32::from(pair[1])).abs() as u32;
+ d0 * d0 + d1 * d1
+}
+
+fn in_range(base: i8, delta: i8) -> bool {
+ if let Some(val) = base.checked_add(delta) {
+ val >= 0
+ } else {
+ false
+ }
+}
+
+fn find_pair(cb_data: &[i8], ppair: &[u8], cpair: &[u8]) -> u8 {
+ let ppair = [ppair[0] as i8, ppair[1] as i8];
+ let diff = [(cpair[0] as i8) - ppair[0], (cpair[1] as i8) - ppair[1]];
+ // pair 0 is always zero;
+ if diff == [0, 0] {
+ return 0;
+ }
+ let mut best_idx = 0;
+ let mut best_dist = pair_dist(&diff, &[0, 0]);
+ for (idx, cbpair) in cb_data.chunks(2).enumerate().skip(1) {
+ let dist = pair_dist(&diff, cbpair);
+ if dist < best_dist && in_range(ppair[0], cbpair[0]) && in_range(ppair[1], cbpair[1]) {
+ best_dist = dist;
+ best_idx = idx;
+ }
+ }
+ best_idx as u8
+}
+
+fn find_quad(cb_data: &[i8], prev: &[u8], cur: &[u8]) -> (u8, u8) {
+ let (ppair1, ppair0) = prev.split_at(2);
+ let (cpair1, cpair0) = cur.split_at(2);
+ let idx1 = find_pair(cb_data, ppair1, cpair1);
+ let idx0 = find_pair(cb_data, ppair0, cpair0);
+ (idx0, idx1)
+}
+
+const REQUANT_TAB: [[u8; 128]; 8] = [
+ [
+ 0x00, 0x02, 0x02, 0x04, 0x04, 0x06, 0x06, 0x08,
+ 0x08, 0x0a, 0x0a, 0x0c, 0x0c, 0x0e, 0x0e, 0x10,
+ 0x10, 0x12, 0x12, 0x14, 0x14, 0x16, 0x16, 0x18,
+ 0x18, 0x1a, 0x1a, 0x1c, 0x1c, 0x1e, 0x1e, 0x20,
+ 0x20, 0x22, 0x22, 0x24, 0x24, 0x26, 0x26, 0x28,
+ 0x28, 0x2a, 0x2a, 0x2c, 0x2c, 0x2e, 0x2e, 0x30,
+ 0x30, 0x32, 0x32, 0x34, 0x34, 0x36, 0x36, 0x38,
+ 0x38, 0x3a, 0x3a, 0x3c, 0x3c, 0x3e, 0x3e, 0x40,
+ 0x40, 0x42, 0x42, 0x44, 0x44, 0x46, 0x46, 0x48,
+ 0x48, 0x4a, 0x4a, 0x4c, 0x4c, 0x4e, 0x4e, 0x50,
+ 0x50, 0x52, 0x52, 0x54, 0x54, 0x56, 0x56, 0x58,
+ 0x58, 0x5a, 0x5a, 0x5c, 0x5c, 0x5e, 0x5e, 0x60,
+ 0x60, 0x62, 0x62, 0x64, 0x64, 0x66, 0x66, 0x68,
+ 0x68, 0x6a, 0x6a, 0x6c, 0x6c, 0x6e, 0x6e, 0x70,
+ 0x70, 0x72, 0x72, 0x74, 0x74, 0x76, 0x76, 0x78,
+ 0x78, 0x7a, 0x7a, 0x7c, 0x7c, 0x7e, 0x7e, 0x7e
+ ], [
+ 0x01, 0x01, 0x04, 0x04, 0x04, 0x07, 0x07, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0d, 0x0d, 0x0d, 0x10, 0x10,
+ 0x10, 0x13, 0x13, 0x13, 0x16, 0x16, 0x16, 0x19,
+ 0x19, 0x19, 0x1c, 0x1c, 0x1c, 0x1f, 0x1f, 0x1f,
+ 0x22, 0x22, 0x22, 0x25, 0x25, 0x25, 0x28, 0x28,
+ 0x28, 0x2b, 0x2b, 0x2b, 0x2e, 0x2e, 0x2e, 0x31,
+ 0x31, 0x31, 0x34, 0x34, 0x34, 0x37, 0x37, 0x37,
+ 0x3a, 0x3a, 0x3a, 0x3d, 0x3d, 0x3d, 0x40, 0x40,
+ 0x40, 0x43, 0x43, 0x43, 0x46, 0x46, 0x46, 0x49,
+ 0x49, 0x49, 0x4c, 0x4c, 0x4c, 0x4f, 0x4f, 0x4f,
+ 0x52, 0x52, 0x52, 0x55, 0x55, 0x55, 0x58, 0x58,
+ 0x58, 0x5b, 0x5b, 0x5b, 0x5e, 0x5e, 0x5e, 0x61,
+ 0x61, 0x61, 0x64, 0x64, 0x64, 0x67, 0x67, 0x67,
+ 0x6a, 0x6a, 0x6a, 0x6d, 0x6d, 0x6d, 0x70, 0x70,
+ 0x70, 0x73, 0x73, 0x73, 0x76, 0x76, 0x76, 0x76,
+ 0x76, 0x79, 0x7c, 0x7c, 0x7c, 0x7f, 0x7f, 0x7f
+ ], [
+ 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x08, 0x08,
+ 0x08, 0x08, 0x0c, 0x0c, 0x0c, 0x0c, 0x10, 0x10,
+ 0x10, 0x10, 0x14, 0x14, 0x14, 0x14, 0x18, 0x18,
+ 0x18, 0x18, 0x1c, 0x1c, 0x1c, 0x1c, 0x20, 0x20,
+ 0x20, 0x20, 0x24, 0x24, 0x24, 0x24, 0x28, 0x28,
+ 0x28, 0x28, 0x2c, 0x2c, 0x2c, 0x2c, 0x30, 0x30,
+ 0x30, 0x30, 0x34, 0x34, 0x34, 0x34, 0x38, 0x38,
+ 0x38, 0x38, 0x3c, 0x3c, 0x3c, 0x3c, 0x40, 0x40,
+ 0x40, 0x40, 0x44, 0x44, 0x44, 0x44, 0x48, 0x48,
+ 0x48, 0x48, 0x4c, 0x4c, 0x4c, 0x4c, 0x50, 0x50,
+ 0x50, 0x50, 0x54, 0x54, 0x54, 0x54, 0x58, 0x58,
+ 0x58, 0x58, 0x5c, 0x5c, 0x5c, 0x5c, 0x60, 0x60,
+ 0x60, 0x60, 0x64, 0x64, 0x64, 0x64, 0x68, 0x68,
+ 0x68, 0x68, 0x6c, 0x6c, 0x6c, 0x6c, 0x70, 0x70,
+ 0x70, 0x70, 0x74, 0x74, 0x74, 0x74, 0x78, 0x78,
+ 0x78, 0x78, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c
+ ], [
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x13, 0x13, 0x13, 0x13, 0x13, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x22, 0x22, 0x22, 0x22, 0x22, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x31, 0x31, 0x31, 0x31, 0x31, 0x36, 0x36, 0x36,
+ 0x36, 0x36, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x45, 0x45, 0x45, 0x45,
+ 0x45, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4f, 0x4f,
+ 0x4f, 0x4f, 0x4f, 0x54, 0x54, 0x54, 0x54, 0x54,
+ 0x59, 0x59, 0x59, 0x59, 0x59, 0x5e, 0x5e, 0x5e,
+ 0x5e, 0x5e, 0x63, 0x63, 0x63, 0x63, 0x63, 0x68,
+ 0x68, 0x68, 0x68, 0x68, 0x6d, 0x6d, 0x6d, 0x6d,
+ 0x6d, 0x72, 0x72, 0x72, 0x72, 0x72, 0x77, 0x77,
+ 0x77, 0x77, 0x77, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c
+ ], [
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x34, 0x34, 0x34, 0x34, 0x34,
+ 0x34, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x46, 0x46, 0x46,
+ 0x46, 0x46, 0x46, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,
+ 0x4c, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x58,
+ 0x58, 0x58, 0x58, 0x58, 0x58, 0x5e, 0x5e, 0x5e,
+ 0x5e, 0x5e, 0x5e, 0x64, 0x64, 0x64, 0x64, 0x64,
+ 0x64, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x70,
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x76, 0x76, 0x76,
+ 0x76, 0x76, 0x76, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c
+ ], [
+ 0x01, 0x01, 0x01, 0x01, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x32, 0x32,
+ 0x32, 0x32, 0x32, 0x32, 0x32, 0x39, 0x39, 0x39,
+ 0x39, 0x39, 0x39, 0x39, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x47, 0x47, 0x47, 0x47, 0x47,
+ 0x47, 0x47, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e,
+ 0x4e, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+ 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x63,
+ 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x6a, 0x6a,
+ 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x71, 0x71, 0x71,
+ 0x71, 0x71, 0x71, 0x71, 0x78, 0x78, 0x78, 0x78,
+ 0x78, 0x78, 0x78, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ ], [
+ 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x30, 0x30, 0x30, 0x30,
+ 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38,
+ 0x38, 0x38, 0x38, 0x38, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x48, 0x48, 0x48, 0x48,
+ 0x48, 0x48, 0x48, 0x48, 0x50, 0x50, 0x50, 0x50,
+ 0x50, 0x50, 0x50, 0x50, 0x58, 0x58, 0x58, 0x58,
+ 0x58, 0x58, 0x58, 0x58, 0x60, 0x60, 0x60, 0x60,
+ 0x60, 0x60, 0x60, 0x60, 0x68, 0x68, 0x68, 0x68,
+ 0x68, 0x68, 0x68, 0x68, 0x70, 0x70, 0x70, 0x70,
+ 0x70, 0x70, 0x70, 0x70, 0x78, 0x78, 0x78, 0x78,
+ 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78
+ ], [
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
+ 0x37, 0x37, 0x37, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x49, 0x49, 0x49, 0x49,
+ 0x49, 0x49, 0x49, 0x49, 0x49, 0x52, 0x52, 0x52,
+ 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x5b, 0x5b,
+ 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x64,
+ 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64,
+ 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d,
+ 0x6d, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+ 0x76, 0x76, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ ]
+];
projects / nihav.git / blobdiff