-use nihav_core::frame::NAVideoBuffer;
-use nihav_core::codecs::MV;
-use nihav_core::codecs::blockdsp::edge_emu;
+use nihav_core::frame::{NAVideoBuffer, NASimpleVideoFrame};
+use nihav_codec_support::codecs::MV;
+use nihav_codec_support::codecs::blockdsp::edge_emu;
fn clip8(val: i16) -> u8 { val.min(255).max(0) as u8 }
});
}
+#[allow(clippy::cognitive_complexity)]
fn luma_mc(dst: &mut [u8], mut didx: usize, dstride: usize, src: &[u8], mut sidx: usize, sstride: usize, w: usize, h: usize, cx: usize, cy: usize) {
if (cx == 0) && (cy == 0) {
for _ in 0..h {
- for x in 0..w { dst[didx + x] = src[sidx + x]; }
+ dst[didx..][..w].copy_from_slice(&src[sidx..][..w]);
didx += dstride;
sidx += sstride;
}
fn chroma_mc(dst: &mut [u8], mut didx: usize, dstride: usize, src: &[u8], mut sidx: usize, sstride: usize, w: usize, h: usize, x: usize, y: usize) {
if (x == 0) && (y == 0) {
for _ in 0..h {
- for x in 0..w { dst[didx + x] = src[sidx + x]; }
+ dst[didx..][..w].copy_from_slice(&src[sidx..][..w]);
didx += dstride;
sidx += sstride;
}
return;
}
if (x > 0) && (y > 0) {
- let a = ((4 - x) * (4 - y)) as u16;
- let b = (( x) * (4 - y)) as u16;
- let c = ((4 - x) * ( y)) as u16;
- let d = (( x) * ( y)) as u16;
+ // 3,3 case is the same as 3,2 for some reason
+ let ymod = if (x == 3) && (y == 3) { 2 } else { y };
+ let a = ((4 - x) * (4 - ymod)) as u16;
+ let b = (( x) * (4 - ymod)) as u16;
+ let c = ((4 - x) * ( ymod)) as u16;
+ let d = (( x) * ( ymod)) as u16;
for _ in 0..h {
for x in 0..w {
dst[didx + x] = ((a * (src[sidx + x] as u16)
)
}
macro_rules! strength{
- ($el: expr, $lim: expr) => (if $el < $lim { 3 } else { 1 })
+ ($el: expr, $lim: expr) => (if $el.abs() < $lim { 3 } else { 1 })
}
fn clip_symm(val: i16, lim: i16) -> i16 { val.max(-lim).min(lim) }
let str_q = strength!(diff_p1p0[0] + diff_p1p0[1] + diff_p1p0[2] + diff_p1p0[3], lim2);
if str_p + str_q > 2 {
let msum = ((mode1 + mode2 + str_q + str_p) >> 1) as i16;
- let (maxprod, weak) = if (str_q == 1) || (str_p == 1) { (512, true) } else { (384, false) };
+ let (maxprod, weak) = if (str_q == 1) || (str_p == 1) { (384, true) } else { (256, false) };
for y in 0..4 {
let diff_p0q0 = diff!(dst, offset, offset - step);
- if (diff_p0q0 != 0) && (lim1 * diff_p0q0.abs() < maxprod) {
+ if (diff_p0q0 != 0) && (((lim1 * diff_p0q0.abs()) & !0x7F) <= maxprod) {
let diff_q1q2 = diff!(dst, offset - 2 * step, offset - 3 * step);
let diff_p1p2 = diff!(dst, offset + step, offset + 2 * step);
let delta = if weak {
};
dst[offset - step] = clip8((dst[offset - step] as i16) + delta);
dst[offset] = clip8((dst[offset] as i16) - delta);
- if (str_q != 1) && (diff_q1q2.abs() <= (lim1 >> 2)) {
+ if (str_q != 1) && (diff_q1q2.abs() <= (lim2 >> 2)) {
let diff = (diff_q1q0[y] + diff_q1q2 - delta) >> 1;
let delta_q1 = if weak {
clip_symm(diff, (mode1 >> 1) as i16)
};
dst[offset - 2 * step] = clip8((dst[offset - 2 * step] as i16) - delta_q1);
}
- if (str_p != 1) && (diff_p1p2.abs() <= (lim1 >> 2)) {
+ if (str_p != 1) && (diff_p1p2.abs() <= (lim2 >> 2)) {
let diff = (diff_p1p0[y] + diff_p1p2 + delta) >> 1;
let delta_p1 = if weak {
clip_symm(diff, (mode2 >> 1) as i16)
let str_p = strength!(diff_p, lim2);
if str_p + str_q > 2 {
let msum = ((mode1 + mode2 + str_q + str_p) >> 1) as i16;
- let (maxprod, weak) = if (str_q == 1) || (str_p == 1) { (512, true) } else { (384, false) };
+ let (maxprod, weak) = if (str_q == 1) || (str_p == 1) { (384, true) } else { (256, false) };
for _ in 0..2 {
let diff_pq = diff!(dst, offset, offset - step);
- if (diff_pq != 0) && (lim1 * diff_pq.abs() < maxprod) {
+ if (diff_pq != 0) && (((lim1 * diff_pq.abs()) & !0x7F) <= maxprod) {
let delta = if weak {
clip_symm((diff_pq + 1) >> 1, msum >> 1)
} else {
blk[off + 0 * step] = ((tm0 + tt0 + 64) >> 7) as i16;
blk[off + 1 * step] = ((tm4 + tt1 + 64) >> 7) as i16;
blk[off + 2 * step] = ((tm6 + tt2 + 64) >> 7) as i16;
- blk[off + 3 * step] = ((tm4 + tt3 + 64) >> 7) as i16;
+ blk[off + 3 * step] = ((tm2 + tt3 + 64) >> 7) as i16;
blk[off + 4 * step] = ((tm3 + tt4 + 64) >> 7) as i16;
blk[off + 5 * step] = ((tm7 + tt5 + 64) >> 7) as i16;
blk[off + 6 * step] = ((tm5 + tt6 + 64) >> 7) as i16;
sidx += sstride;
}
}
- pub fn do_avg(&self, frame: &mut NAVideoBuffer<u8>, prev_frame: &NAVideoBuffer<u8>, x: usize, y: usize, w: usize, h: usize) {
+ pub fn do_avg(&self, frame: &mut NASimpleVideoFrame<u8>, prev_frame: &NAVideoBuffer<u8>, x: usize, y: usize, w: usize, h: usize) {
for comp in 0..3 {
- let dstride = frame.get_stride(comp);
+ let dstride = frame.stride[comp];
let sstride = prev_frame.get_stride(comp);
- let doff = if comp == 0 { x + y * dstride } else { frame.get_offset(comp) + (x >> 1) + (y >> 1) * dstride };
+ let doff = if comp == 0 { x + y * dstride } else { frame.offset[comp] + (x >> 1) + (y >> 1) * dstride };
let soff = prev_frame.get_offset(comp);
- let ddata = frame.get_data_mut().unwrap();
- let dst: &mut [u8] = ddata.as_mut_slice();
+ let dst = &mut frame.data;
let sdata = prev_frame.get_data();
let src: &[u8] = sdata.as_slice();
}
}
}
- pub fn do_mc(&self, frame: &mut NAVideoBuffer<u8>, prev_frame: &NAVideoBuffer<u8>, x: usize, y: usize, w: usize, h: usize, mv: MV, avg: bool) {
+ pub fn do_mc(&self, frame: &mut NASimpleVideoFrame<u8>, prev_frame: &NAVideoBuffer<u8>, x: usize, y: usize, w: usize, h: usize, mv: MV, avg: bool) {
{ // luma
- let dstride = frame.get_stride(0);
- let doffset = frame.get_offset(0) + (if !avg { x + y * dstride } else { 0 });
- let data = frame.get_data_mut().unwrap();
- let dst: &mut [u8] = data.as_mut_slice();
+ let dstride = frame.stride[0];
+ let doffset = frame.offset[0] + (if !avg { x + y * dstride } else { 0 });
+ let dst = &mut frame.data;
let (w_, h_) = prev_frame.get_dimensions(0);
let fw = (w_ + 15) & !15;
luma_mc(dst, doffset, dstride, src, soffset, sstride, w, h, cx, cy);
} else {
let mut ebuf: [u8; 70*70] = [0; 70*70];
- edge_emu(prev_frame, (x as isize) + (dx as isize) - 2, (y as isize) + (dy as isize) - 2, w+5, h+5, &mut ebuf, 70, 0);
+ edge_emu(prev_frame, (x as isize) + (dx as isize) - 2, (y as isize) + (dy as isize) - 2, w+5, h+5, &mut ebuf, 70, 0, 4);
luma_mc(dst, doffset, dstride, &ebuf, 70*2 + 2, 70, w, h, cx, cy);
}
}
let ch = h >> 1;
for comp in 1..3 { // chroma
- let dstride = frame.get_stride(comp);
- let doffset = frame.get_offset(comp) + (if !avg { (x >> 1) + (y >> 1) * dstride } else { 0 });
- let data = frame.get_data_mut().unwrap();
- let dst: &mut [u8] = data.as_mut_slice();
+ let dstride = frame.stride[comp];
+ let doffset = frame.offset[comp] + (if !avg { (x >> 1) + (y >> 1) * dstride } else { 0 });
if check_pos(x >> 1, y >> 1, cw, ch, fw, fh, dx, dy, 0, 1, 0, 1) {
let sstride = prev_frame.get_stride(comp);
let mut soffset = prev_frame.get_offset(comp) + (x >> 1) + (y >> 1) * sstride;
let data = prev_frame.get_data();
let src: &[u8] = data.as_slice();
soffset = ((soffset as isize) + (dx as isize) + (dy as isize) * (sstride as isize)) as usize;
- chroma_mc(dst, doffset, dstride, src, soffset, sstride, cw, ch, cx, cy);
+ chroma_mc(frame.data, doffset, dstride, src, soffset, sstride, cw, ch, cx, cy);
} else {
let mut ebuf: [u8; 40*40] = [0; 40*40];
- edge_emu(prev_frame, ((x >> 1) as isize) + (dx as isize), ((y >> 1) as isize) + (dy as isize), cw+1, ch+1, &mut ebuf, 40, comp);
- chroma_mc(dst, doffset, dstride, &ebuf, 0, 40, cw, ch, cx, cy);
+ edge_emu(prev_frame, ((x >> 1) as isize) + (dx as isize), ((y >> 1) as isize) + (dy as isize), cw+1, ch+1, &mut ebuf, 40, comp, 3);
+ chroma_mc(frame.data, doffset, dstride, &ebuf, 0, 40, cw, ch, cx, cy);
}
}
}
- fn deblock_edge4_ver(&self, frame: &mut NAVideoBuffer<u8>, xpos: usize, ypos: usize,
+ fn deblock_edge4_ver(&self, frame: &mut NASimpleVideoFrame<u8>, xpos: usize, ypos: usize,
dblk_l: u8, dblk_r: u8, deblock_chroma: bool) {
let qp_l = dblk_l >> 2;
let str_l = dblk_l & 3;
let lim1 = dl_r[2] as i16;
let lim2 = (dl_r[3] * 4) as i16;
{
- let stride = frame.get_stride(0);
- let offset = frame.get_offset(0) + xpos + ypos * stride;
- let data = frame.get_data_mut().unwrap();
- let dst: &mut [u8] = data.as_mut_slice();
- filter_luma_edge(dst, offset, 1, stride, mode_l, mode_r, lim1, lim2);
+ let stride = frame.stride[0];
+ let offset = frame.offset[0] + xpos + ypos * stride;
+ filter_luma_edge(frame.data, offset, 1, stride, mode_l, mode_r, lim1, lim2);
}
if ((str_l | str_r) >= 2) && deblock_chroma {
- for comp in 1..2 {
- let stride = frame.get_stride(comp);
- let offset = frame.get_offset(comp) + (xpos >> 1) + (ypos >> 1) * stride;
- let data = frame.get_data_mut().unwrap();
- let dst: &mut [u8] = data.as_mut_slice();
- filter_chroma_edge(dst, offset, 1, stride, mode_l, mode_r, lim1, lim2);
+ for comp in 1..3 {
+ let stride = frame.stride[comp];
+ let offset = frame.offset[comp] + (xpos >> 1) + (ypos >> 1) * stride;
+ filter_chroma_edge(frame.data, offset, 1, stride, mode_l, mode_r, lim1, lim2);
}
}
}
- fn deblock_edge4_hor(&self, frame: &mut NAVideoBuffer<u8>, xpos: usize, ypos: usize,
+ fn deblock_edge4_hor(&self, frame: &mut NASimpleVideoFrame<u8>, xpos: usize, ypos: usize,
dblk_t: u8, dblk_d: u8, deblock_chroma: bool) {
let qp_t = dblk_t >> 2;
let str_t = dblk_t & 3;
let lim1 = dl_d[2] as i16;
let lim2 = (dl_d[3] * 4) as i16;
{
- let stride = frame.get_stride(0);
- let offset = frame.get_offset(0) + xpos + ypos * stride;
- let data = frame.get_data_mut().unwrap();
- let dst: &mut [u8] = data.as_mut_slice();
- filter_luma_edge(dst, offset, stride, 1, mode_t, mode_d, lim1, lim2);
+ let stride = frame.stride[0];
+ let offset = frame.offset[0] + xpos + ypos * stride;
+ filter_luma_edge(frame.data, offset, stride, 1, mode_t, mode_d, lim1, lim2);
}
if ((str_t | str_d) >= 2) && deblock_chroma {
- for comp in 1..2 {
- let stride = frame.get_stride(comp);
- let offset = frame.get_offset(comp) + (xpos >> 1) + (ypos >> 1) * stride;
- let data = frame.get_data_mut().unwrap();
- let dst: &mut [u8] = data.as_mut_slice();
- filter_chroma_edge(dst, offset, stride, 1, mode_t, mode_d, lim1, lim2);
+ for comp in 1..3 {
+ let stride = frame.stride[comp];
+ let offset = frame.offset[comp] + (xpos >> 1) + (ypos >> 1) * stride;
+ filter_chroma_edge(frame.data, offset, stride, 1, mode_t, mode_d, lim1, lim2);
}
}
}
- fn deblock8x8(&self, dparams: &RV60DeblockParams, frame: &mut NAVideoBuffer<u8>,
+ fn deblock8x8(&self, dparams: &RV60DeblockParams, frame: &mut NASimpleVideoFrame<u8>,
xpos: usize, ypos: usize, top_str: &[u8], left_str: &[u8], dblkpos: usize) {
if xpos > 0 {
if ypos > 0 {
- let str_l = left_str[dblkpos - dparams.dblkstride];
- let str_r = left_str[dblkpos];
- if (str_l | str_r) != 0 {
+ let str_l = left_str[dblkpos - dparams.dblkstride - 1];
+ let str_r = left_str[dblkpos - dparams.dblkstride];
+ if ((str_l | str_r) & 3) != 0 {
self.deblock_edge4_ver(frame, xpos, ypos - 4, str_l, str_r, dparams.deblock_chroma);
}
}
{
- let str_l = left_str[dblkpos];
- let str_r = left_str[dblkpos + dparams.dblkstride];
- if (str_l | str_r) != 0 {
+ let str_l = left_str[dblkpos - 1];
+ let str_r = left_str[dblkpos];
+ if ((str_l | str_r) & 3) != 0 {
self.deblock_edge4_ver(frame, xpos, ypos + 0, str_l, str_r, dparams.deblock_chroma);
}
}
- if ypos + 4 >= dparams.height {
- let str_l = left_str[dblkpos + dparams.dblkstride];
- let str_r = left_str[dblkpos + dparams.dblkstride * 2];
- if (str_l | str_r) != 0 {
+ if ypos + 8 >= dparams.height {
+ let str_l = left_str[dblkpos + dparams.dblkstride - 1];
+ let str_r = left_str[dblkpos + dparams.dblkstride];
+ if ((str_l | str_r) & 3) != 0 {
self.deblock_edge4_ver(frame, xpos, ypos + 4, str_l, str_r, dparams.deblock_chroma);
}
}
}
if ypos > 0 {
if xpos > 0 {
- let str_t = top_str[dblkpos - 1];
- let str_d = top_str[dblkpos];
- if (str_t | str_d) != 0 {
+ let str_t = top_str[dblkpos - dparams.dblkstride - 1];
+ let str_d = top_str[dblkpos - 1];
+ if ((str_t | str_d) & 3) != 0 {
self.deblock_edge4_hor(frame, xpos - 4, ypos, str_t, str_d, dparams.deblock_chroma);
}
}
{
- let str_t = top_str[dblkpos];
- let str_d = top_str[dblkpos + 1];
- if (str_t | str_d) != 0 {
+ let str_t = top_str[dblkpos - dparams.dblkstride];
+ let str_d = top_str[dblkpos];
+ if ((str_t | str_d) & 3) != 0 {
self.deblock_edge4_hor(frame, xpos + 0, ypos, str_t, str_d, dparams.deblock_chroma);
}
}
- if xpos + 4 >= dparams.width {
- let str_t = top_str[dblkpos + 1];
- let str_d = top_str[dblkpos + 2];
- if (str_t | str_d) != 0 {
+ if xpos + 8 >= dparams.width {
+ let str_t = top_str[dblkpos - dparams.dblkstride + 1];
+ let str_d = top_str[dblkpos + 1];
+ if ((str_t | str_d) & 3) != 0 {
self.deblock_edge4_hor(frame, xpos + 4, ypos, str_t, str_d, dparams.deblock_chroma);
}
}
}
}
- pub fn do_deblock(&self, dparams: &RV60DeblockParams, frame: &mut NAVideoBuffer<u8>,
+ pub fn do_deblock(&self, dparams: &RV60DeblockParams, frame: &mut NASimpleVideoFrame<u8>,
xpos: usize, ypos: usize, size: usize, top_str: &[u8], left_str: &[u8], dpos: usize) {
for x in 0..(size >> 3) {
self.deblock8x8(dparams, frame, xpos + x * 8, ypos,
let off = ((sum >> 5) + 32) as usize;
let frac = (sum & 0x1F) as u16;
if frac == 0 {
- for x in 0..size {
- dst[doff + x] = src[off + x];
- }
+ dst[doff..][..size].copy_from_slice(&src[off..][..size]);
} else {
for x in 0..size {
let a = src[off + x + 0] as u16;
sum += diff;
}
}
+ #[allow(clippy::cognitive_complexity)]
pub fn pred_angle(&self, dst: &mut [u8], mut doff: usize, dstride: usize, size: usize, angle: usize, filter: bool) {
let mut filtered1: [u8; 96] = [0; 96];
let mut filtered2: [u8; 96] = [0; 96];
let inv_angle = RV60_IPRED_INV_ANGLE[angle - 10];
let add_size = (size * (ang_weight as usize) + 31) >> 5;
if size <= 16 {
- for i in 0..size+1 {
+ for i in 0..=size {
filtered1[32-1 + i] = self.l[i];
}
- for i in 0..size+1 {
+ for i in 0..=size {
filtered2[32-1 + i] = self.t[i];
}
} else {
let inv_angle = RV60_IPRED_INV_ANGLE[26 - angle];
let add_size = (size * (ang_weight as usize) + 31) >> 5;
if size <= 16 {
- for i in 0..size+1 {
+ for i in 0..=size {
filtered1[32-1 + i] = self.t[i];
}
- for i in 0..size+1 {
+ for i in 0..=size {
filtered2[32-1 + i] = self.l[i];
}
} else {
Self::filter_bilin32(&mut filtered1[32..], self.t[1], self.t[33], 32);
}
for _ in 0..size {
- for x in 0..size {
- dst[doff + x] = filtered1[32 + x];
- }
+ dst[doff..][..size].copy_from_slice(&filtered1[32..][..size]);
doff += dstride;
}
if filter {
projects / nihav.git / blobdiff