X-Git-Url: https://git.nihav.org/?p=nihav.git;a=blobdiff_plain;f=nihav-duck%2Fsrc%2Fcodecs%2Fvpcommon.rs;h=0392a383b5248a4647e3b734b43534668e07c4f2;hp=cac264b8c51301060a45e860085799f26a19ceed;hb=3584b223ce417fe167dc90cb9a40e173f34823c0;hpb=5b24175d582e438c4b8ccb685e2eb5913178fc3e diff --git a/nihav-duck/src/codecs/vpcommon.rs b/nihav-duck/src/codecs/vpcommon.rs index cac264b..0392a38 100644 --- a/nihav-duck/src/codecs/vpcommon.rs +++ b/nihav-duck/src/codecs/vpcommon.rs @@ -1,4 +1,5 @@ use nihav_core::codecs::*; +use nihav_core::codecs::blockdsp::*; #[derive(Clone,Copy,Debug,PartialEq)] #[allow(dead_code)] @@ -15,6 +16,9 @@ pub enum VPMBType { GoldenNear, } +pub const VP_REF_INTER: u8 = 1; +pub const VP_REF_GOLDEN: u8 = 2; + #[allow(dead_code)] impl VPMBType { pub fn is_intra(self) -> bool { self == VPMBType::Intra } @@ -25,8 +29,8 @@ impl VPMBType { VPMBType::InterMV | VPMBType::InterNearest | VPMBType::InterNear | - VPMBType::InterFourMV => 1, - _ => 2, + VPMBType::InterFourMV => VP_REF_INTER, + _ => VP_REF_GOLDEN, } } } @@ -66,6 +70,103 @@ impl VPShuffler { } } +#[allow(dead_code)] +pub struct BoolCoder<'a> { + pub src: &'a [u8], + pos: usize, + value: u32, + range: u32, + bits: i32, +} + +#[allow(dead_code)] +impl<'a> BoolCoder<'a> { + pub fn new(src: &'a [u8]) -> DecoderResult { + if src.len() < 3 { return Err(DecoderError::ShortData); } + let value = ((src[0] as u32) << 24) | ((src[1] as u32) << 16) | ((src[2] as u32) << 8) | (src[3] as u32); + Ok(Self { src, pos: 4, value, range: 255, bits: 8 }) + } + pub fn read_bool(&mut self) -> bool { + self.read_prob(128) + } + pub fn read_prob(&mut self, prob: u8) -> bool { + self.renorm(); + let split = 1 + (((self.range - 1) * (prob as u32)) >> 8); + let bit; + if self.value < (split << 24) { + self.range = split; + bit = false; + } else { + self.range -= split; + self.value -= split << 24; + bit = true; + } + bit + } + pub fn read_bits(&mut self, bits: u8) -> u32 { + let mut val = 0u32; + for _ in 0..bits { + val = (val << 1) | (self.read_prob(128) as u32); + } + val + } + pub fn read_probability(&mut self) -> u8 { + let val = self.read_bits(7) as u8; + if val == 0 { + 1 + } else { + val << 1 + } + } + fn renorm(&mut self) { + let shift = self.range.leading_zeros() & 7; + self.range <<= shift; + self.value <<= shift; + self.bits -= shift as i32; + if (self.bits <= 0) && (self.pos < self.src.len()) { + self.value |= (self.src[self.pos] as u32) << (-self.bits as u8); + self.pos += 1; + self.bits += 8; + } +/* while self.range < 0x80 { + self.range <<= 1; + self.value <<= 1; + self.bits -= 1; + if (self.bits <= 0) && (self.pos < self.src.len()) { + self.value |= self.src[self.pos] as u32; + self.pos += 1; + self.bits = 8; + } + }*/ + } + pub fn skip_bytes(&mut self, nbytes: usize) { + for _ in 0..nbytes { + self.value <<= 8; + if self.pos < self.src.len() { + self.value |= self.src[self.pos] as u32; + self.pos += 1; + } + } + } +} + +#[allow(dead_code)] +pub fn rescale_prob(prob: u8, weights: &[i16; 2], maxval: i32) -> u8 { + ((((prob as i32) * (weights[0] as i32) + 128) >> 8) + (weights[1] as i32)).min(maxval).max(1) as u8 +} + +#[macro_export] +macro_rules! vp_tree { + ($bc: expr, $prob: expr, $node1: expr, $node2: expr) => { + if !$bc.read_prob($prob) { + $node1 + } else { + $node2 + } + }; + ($leaf: expr) => { $leaf } +} + const C1S7: i32 = 64277; const C2S6: i32 = 60547; const C3S5: i32 = 54491; @@ -152,6 +253,17 @@ pub fn vp_put_block(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usize, } } +pub fn vp_put_block_ilace(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usize, frm: &mut NASimpleVideoFrame) { + vp_idct(coeffs); + let mut off = frm.offset[plane] + bx * 8 + ((by & !1) * 8 + (by & 1)) * frm.stride[plane]; + for y in 0..8 { + for x in 0..8 { + frm.data[off + x] = (coeffs[x + y * 8] + 128).min(255).max(0) as u8; + } + off += frm.stride[plane] * 2; + } +} + pub fn vp_put_block_dc(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usize, frm: &mut NASimpleVideoFrame) { vp_idct_dc(coeffs); let dc = (coeffs[0] + 128).min(255).max(0) as u8; @@ -175,6 +287,17 @@ pub fn vp_add_block(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usize, } } +pub fn vp_add_block_ilace(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usize, frm: &mut NASimpleVideoFrame) { + vp_idct(coeffs); + let mut off = frm.offset[plane] + bx * 8 + ((by & !1) * 8 + (by & 1)) * frm.stride[plane]; + for y in 0..8 { + for x in 0..8 { + frm.data[off + x] = (coeffs[x + y * 8] + (frm.data[off + x] as i16)).min(255).max(0) as u8; + } + off += frm.stride[plane] * 2; + } +} + pub fn vp_add_block_dc(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usize, frm: &mut NASimpleVideoFrame) { vp_idct_dc(coeffs); let dc = coeffs[0]; @@ -186,3 +309,117 @@ pub fn vp_add_block_dc(coeffs: &mut [i16; 64], bx: usize, by: usize, plane: usiz off += frm.stride[plane]; } } + +pub fn vp31_loop_filter(data: &mut [u8], mut off: usize, step: usize, stride: usize, + len: usize, loop_str: i16) { + for _ in 0..len { + let a = data[off - step * 2] as i16; + let b = data[off - step] as i16; + let c = data[off] as i16; + let d = data[off + step] as i16; + let mut diff = ((a - d) + 3 * (c - b) + 4) >> 3; + if diff.abs() >= 2 * loop_str { + diff = 0; + } else if diff.abs() >= loop_str { + if diff < 0 { + diff = -diff - 2 * loop_str; + } else { + diff = -diff + 2 * loop_str; + } + } + if diff != 0 { + data[off - step] = (b + diff).max(0).min(255) as u8; + data[off] = (c - diff).max(0).min(255) as u8; + } + + off += stride; + } +} + +pub fn vp_copy_block(dst: &mut NASimpleVideoFrame, src: NAVideoBufferRef, comp: usize, + dx: usize, dy: usize, mv_x: i16, mv_y: i16, + preborder: usize, postborder: usize, loop_str: i16, + mode: usize, interp: &[BlkInterpFunc], mut mc_buf: NAVideoBufferRef) +{ + let sx = (dx as isize) + (mv_x as isize); + let sy = (dy as isize) + (mv_y as isize); + if ((sx | sy) & 7) == 0 { + copy_block(dst, src, comp, dx, dy, mv_x, mv_y, 8, 8, preborder, postborder, mode, interp); + return; + } + let pre = preborder.max(2); + let post = postborder.max(1); + let bsize = 8 + pre + post; + let src_x = sx - (pre as isize); + let src_y = sy - (pre as isize); + { + let mut tmp_buf = NASimpleVideoFrame::from_video_buf(&mut mc_buf).unwrap(); + copy_block(&mut tmp_buf, src, comp, 0, 0, src_x as i16, src_y as i16, + bsize, bsize, 0, 0, 0, interp); + if (sy & 7) != 0 { + let foff = (8 - (sy & 7)) as usize; + let off = (pre + foff) * tmp_buf.stride[comp]; + vp31_loop_filter(tmp_buf.data, off, tmp_buf.stride[comp], 1, bsize, loop_str); + } + if (sx & 7) != 0 { + let foff = (8 - (sx & 7)) as usize; + let off = pre + foff; + vp31_loop_filter(tmp_buf.data, off, 1, tmp_buf.stride[comp], bsize, loop_str); + } + } + let dxoff = (pre as i16) - (dx as i16); + let dyoff = (pre as i16) - (dy as i16); + copy_block(dst, mc_buf, comp, dx, dy, dxoff, dyoff, 8, 8, preborder, postborder, 0/* mode*/, interp); +} + +fn vp3_interp00(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) +{ + let mut didx = 0; + let mut sidx = 0; + for _ in 0..bh { + for x in 0..bw { dst[didx + x] = src[sidx + x]; } + didx += dstride; + sidx += sstride; + } +} + +fn vp3_interp01(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) +{ + let mut didx = 0; + let mut sidx = 0; + for _ in 0..bh { + for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + 1] as u16)) >> 1) as u8; } + didx += dstride; + sidx += sstride; + } +} + +fn vp3_interp10(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) +{ + let mut didx = 0; + let mut sidx = 0; + for _ in 0..bh { + for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + sstride] as u16)) >> 1) as u8; } + didx += dstride; + sidx += sstride; + } +} + +fn vp3_interp11(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) +{ + let mut didx = 0; + let mut sidx = 0; + for _ in 0..bh { + for x in 0..bw { + dst[didx + x] = (((src[sidx + x] as u16) + + (src[sidx + x + 1] as u16) + + (src[sidx + x + sstride] as u16) + + (src[sidx + x + sstride + 1] as u16)) >> 2) as u8; + } + didx += dstride; + sidx += sstride; + } +} + +pub const VP3_INTERP_FUNCS: &[blockdsp::BlkInterpFunc] = &[ vp3_interp00, vp3_interp01, vp3_interp10, vp3_interp11 ]; +