X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-codec-support%2Fsrc%2Fcodecs%2Fh263%2Fcode.rs;h=cbeb12042fad4946a79d04ce14f238ec6da0de1c;hb=b7c882c1ce6f86c07c2340751200e3a060942826;hp=038041417947f1d0c7987d787bae957143ad1cde;hpb=ebdc6f4103c488c95569eb7864575368e406849e;p=nihav.git diff --git a/nihav-codec-support/src/codecs/h263/code.rs b/nihav-codec-support/src/codecs/h263/code.rs index 0380414..cbeb120 100644 --- a/nihav-codec-support/src/codecs/h263/code.rs +++ b/nihav-codec-support/src/codecs/h263/code.rs @@ -1,7 +1,7 @@ -use nihav_core::frame::NAVideoBuffer; +use nihav_core::frame::{NAVideoBuffer, NAVideoBufferRef, NASimpleVideoFrame}; use super::{BlockDSP, CBPInfo, MV}; use super::super::blockdsp; -//use super::h263data::*; +use super::data::H263_CHROMA_ROUND; /*const W1: i32 = 22725; const W2: i32 = 21407; @@ -221,6 +221,119 @@ pub fn h263_idct(blk: &mut [i16; 64]) { for i in 0..8 { idct_col(blk, i); } } +struct IDCTAnnexW {} + +impl IDCTAnnexW { + const CPO8: i32 = 0x539f; + const SPO8: i32 = 0x4546; + const CPO16: i32 = 0x7d8a; + const SPO16: i32 = 0x18f9; + const C3PO16: i32 = 0x6a6e; + const S3PO16: i32 = 0x471d; + const OOR2: i32 = 0x5a82; + + fn rotate(a: i32, b: i32, c: i32, s: i32, cs: i8, ss: i8) -> (i32, i32) { + let (t00, t10) = if cs > 0 { + ((a * c) >> cs, (b * c) >> cs) + } else { + ((a * c) << -cs, (b * c) << -cs) + }; + let (t01, t11) = if ss > 0 { + ((a * s) >> ss, (b * s) >> ss) + } else { + ((a * s) << -ss, (b * s) << -ss) + }; + ((t01 - t10 + 0x7FFF) >> 16, (t00 + t11 + 0x7FFF) >> 16) + } + + fn bfly(a: i32, b: i32) -> (i32, i32) { (a + b, a - b) } + + fn idct_row(dst: &mut [i32; 64], src: &[i16; 64]) { + for (drow, srow) in dst.chunks_mut(8).zip(src.chunks(8)) { + let s0 = i32::from(srow[0]) << 4; + let s1 = i32::from(srow[1]) << 4; + let s2 = i32::from(srow[2]) << 4; + let s3 = i32::from(srow[3]) << 4; + let s4 = i32::from(srow[4]) << 4; + let s5 = i32::from(srow[5]) << 4; + let s6 = i32::from(srow[6]) << 4; + let s7 = i32::from(srow[7]) << 4; + + let (s2, s6) = Self::rotate(s2, s6, Self::CPO8, Self::SPO8, -2, -1); + let (s1, s7) = Self::rotate(s1, s7, Self::CPO16, Self::SPO16, -1, -1); + let (s3, s5) = Self::rotate(s3, s5, Self::C3PO16, Self::S3PO16, -1, -1); + let (s0, s4) = Self::bfly(s0, s4); + + let (s3, s1) = Self::bfly(s1, s3); + let (s5, s7) = Self::bfly(s7, s5); + let (s0, s6) = Self::bfly(s0, s6); + let (s4, s2) = Self::bfly(s4, s2); + + let (s3, s7) = Self::bfly(s7, s3); + let s1 = (s1 * Self::OOR2 * 4).saturating_add(0x7FFF) >> 16; + let s5 = (s5 * Self::OOR2 * 4).saturating_add(0x7FFF) >> 16; + + drow[1] = s4 + s3; + drow[6] = s4 - s3; + drow[2] = s2 + s7; + drow[5] = s2 - s7; + drow[0] = s0 + s5; + drow[7] = s0 - s5; + drow[3] = s6 + s1; + drow[4] = s6 - s1; + } + } + + #[allow(clippy::erasing_op)] + #[allow(clippy::identity_op)] + fn idct_col(dst: &mut [i16; 64], src: &[i32; 64]) { + for i in 0..8 { + let s0 = src[i + 8 * 0]; + let s1 = src[i + 8 * 1]; + let s2 = src[i + 8 * 2]; + let s3 = src[i + 8 * 3]; + let s4 = src[i + 8 * 4]; + let s5 = src[i + 8 * 5]; + let s6 = src[i + 8 * 6]; + let s7 = src[i + 8 * 7]; + + let (s2, s6) = Self::rotate(s2, s6, Self::CPO8, Self::SPO8, -1, 0); + let (s1, s7) = Self::rotate(s1, s7, Self::CPO16, Self::SPO16, 0, 0); + let (s3, s5) = Self::rotate(s3, s5, Self::C3PO16, Self::S3PO16, 0, 0); + let (a, b) = Self::bfly(s0, s4); + let (s0, s4) = if s4 >= 0 { + (a >> 1, b >> 1) + } else { + ((a + 1) >> 1, (b + 1) >> 1) + }; + + let (s3, s1) = Self::bfly(s1, s3); + let (s5, s7) = Self::bfly(s7, s5); + let (s0, s6) = Self::bfly(s0, s6); + let (s4, s2) = Self::bfly(s4, s2); + + let (s3, s7) = Self::bfly(s7, s3); + let s1 = (s1 * Self::OOR2 * 4).saturating_add(0x7FFF) >> 16; + let s5 = (s5 * Self::OOR2 * 4).saturating_add(0x7FFF) >> 16; + + dst[i + 8 * 1] = ((s4 + s3) >> 6) as i16; + dst[i + 8 * 6] = ((s4 - s3) >> 6) as i16; + dst[i + 8 * 2] = ((s2 + s7) >> 6) as i16; + dst[i + 8 * 5] = ((s2 - s7) >> 6) as i16; + dst[i + 8 * 0] = ((s0 + s5) >> 6) as i16; + dst[i + 8 * 7] = ((s0 - s5) >> 6) as i16; + dst[i + 8 * 3] = ((s6 + s1) >> 6) as i16; + dst[i + 8 * 4] = ((s6 - s1) >> 6) as i16; + } + } +} +#[allow(dead_code)] +pub fn h263_annex_w_idct(blk: &mut [i16; 64]) { + let mut tmp = [0i32; 64]; + IDCTAnnexW::idct_row(&mut tmp, blk); + IDCTAnnexW::idct_col(blk, &tmp); +} + fn h263_interp00(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) { let mut didx = 0; @@ -339,6 +452,7 @@ fn h263_interp11_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, pub const H263_INTERP_AVG_FUNCS: &[blockdsp::BlkInterpFunc] = &[ h263_interp00_avg, h263_interp01_avg, h263_interp10_avg, h263_interp11_avg ]; +#[derive(Default)] pub struct H263BlockDSP { } impl H263BlockDSP { @@ -348,7 +462,7 @@ impl H263BlockDSP { } #[allow(clippy::erasing_op)] -fn deblock_hor(buf: &mut NAVideoBuffer, comp: usize, q: u8, off: usize) { +fn deblock_hor(buf: &mut NAVideoBuffer, comp: usize, strength: u8, off: usize) { let stride = buf.get_stride(comp); let dptr = buf.get_data_mut().unwrap(); let buf = dptr.as_mut_slice(); @@ -357,28 +471,22 @@ fn deblock_hor(buf: &mut NAVideoBuffer, comp: usize, q: u8, off: usize) { let b = buf[off - 1 * stride + x] as i16; let c = buf[off + 0 * stride + x] as i16; let d = buf[off + 1 * stride + x] as i16; - let diff = ((a - d) * 3 + (c - b) * 8) >> 4; - if (diff != 0) && (diff >= -32) && (diff < 32) { - let d0 = diff.abs() * 2 - (q as i16); - let d1 = if d0 < 0 { 0 } else { d0 }; - let d2 = diff.abs() - d1; - let d3 = if d2 < 0 { 0 } else { d2 }; - - let delta = if diff < 0 { -d3 } else { d3 }; - - let b1 = b + delta; - if b1 < 0 { buf[off - 1 * stride + x] = 0; } - else if b1 > 255 { buf[off - 1 * stride + x] = 0xFF; } - else { buf[off - 1 * stride + x] = b1 as u8; } - let c1 = c - delta; - if c1 < 0 { buf[off + x] = 0; } - else if c1 > 255 { buf[off + x] = 0xFF; } - else { buf[off + x] = c1 as u8; } + let diff = ((a - d) + (c - b) * 4) / 8; + if (diff != 0) && (diff > -24) && (diff < 24) { + let d1a = (diff.abs() - 2 * (diff.abs() - (strength as i16)).max(0)).max(0); + let d1 = if diff < 0 { -d1a } else { d1a }; + let hd1 = d1a / 2; + let d2 = ((a - d) / 4).max(-hd1).min(hd1); + + buf[off - 2 * stride + x] = (a - d2) as u8; + buf[off - 1 * stride + x] = (b + d1).max(0).min(255) as u8; + buf[off + 0 * stride + x] = (c - d1).max(0).min(255) as u8; + buf[off + 1 * stride + x] = (d + d2) as u8; } } } -fn deblock_ver(buf: &mut NAVideoBuffer, comp: usize, q: u8, off: usize) { +fn deblock_ver(buf: &mut NAVideoBuffer, comp: usize, strength: u8, off: usize) { let stride = buf.get_stride(comp); let dptr = buf.get_data_mut().unwrap(); let buf = dptr.as_mut_slice(); @@ -387,27 +495,26 @@ fn deblock_ver(buf: &mut NAVideoBuffer, comp: usize, q: u8, off: usize) { let b = buf[off - 1 + y * stride] as i16; let c = buf[off + 0 + y * stride] as i16; let d = buf[off + 1 + y * stride] as i16; - let diff = ((a - d) * 3 + (c - b) * 8) >> 4; - if (diff != 0) && (diff >= -32) && (diff < 32) { - let d0 = diff.abs() * 2 - (q as i16); - let d1 = if d0 < 0 { 0 } else { d0 }; - let d2 = diff.abs() - d1; - let d3 = if d2 < 0 { 0 } else { d2 }; - - let delta = if diff < 0 { -d3 } else { d3 }; - - let b1 = b + delta; - if b1 < 0 { buf[off - 1 + y * stride] = 0; } - else if b1 > 255 { buf[off - 1 + y * stride] = 0xFF; } - else { buf[off - 1 + y * stride] = b1 as u8; } - let c1 = c - delta; - if c1 < 0 { buf[off + y * stride] = 0; } - else if c1 > 255 { buf[off + y * stride] = 0xFF; } - else { buf[off + y * stride] = c1 as u8; } + let diff = (a - d + (c - b) * 4) / 8; + if (diff != 0) && (diff > -24) && (diff < 24) { + let d1a = (diff.abs() - 2 * (diff.abs() - (strength as i16)).max(0)).max(0); + let d1 = if diff < 0 { -d1a } else { d1a }; + let hd1 = d1a / 2; + let d2 = ((a - d) / 4).max(-hd1).min(hd1); + + buf[off - 2 + y * stride] = (a - d2) as u8; + buf[off - 1 + y * stride] = (b + d1).max(0).min(255) as u8; + buf[off + y * stride] = (c - d1).max(0).min(255) as u8; + buf[off + 1 + y * stride] = (d + d2) as u8; } } } +const FILTER_STRENGTH: [u8; 32] = [ + 1, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7, 7, + 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 12 +]; + pub fn h263_filter_row(buf: &mut NAVideoBuffer, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) { let stride = buf.get_stride(0); let mut off = buf.get_offset(0) + mb_y * 16 * stride; @@ -416,9 +523,10 @@ pub fn h263_filter_row(buf: &mut NAVideoBuffer, mb_y: usize, mb_w: usize, cb let coded0 = cbpi.is_coded(mb_x, 0); let coded1 = cbpi.is_coded(mb_x, 1); let q = cbpi.get_q(mb_w + mb_x); + let str = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 }; if mb_y != 0 { - if coded0 && cbpi.is_coded_top(mb_x, 0) { deblock_hor(buf, 0, q, coff); } - if coded1 && cbpi.is_coded_top(mb_x, 1) { deblock_hor(buf, 0, q, coff + 8); } + if coded0 && cbpi.is_coded_top(mb_x, 0) { deblock_hor(buf, 0, str, coff); } + if coded1 && cbpi.is_coded_top(mb_x, 1) { deblock_hor(buf, 0, str, coff + 8); } } let coff = off + 8 * stride; if cbpi.is_coded(mb_x, 2) && coded0 { deblock_hor(buf, 0, q, coff); } @@ -434,14 +542,16 @@ pub fn h263_filter_row(buf: &mut NAVideoBuffer, mb_y: usize, mb_w: usize, cb let ccur0 = cbpi.is_coded(mb_x, 0); let ccur1 = cbpi.is_coded(mb_x, 1); let q = cbpi.get_q(mb_w + mb_x); + let str = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 }; if mb_y != 0 { let coff = off - 8 * stride; let qtop = cbpi.get_q(mb_x); - if leftt && ctop0 { deblock_ver(buf, 0, qtop, coff); } - if ctop0 && ctop1 { deblock_ver(buf, 0, qtop, coff + 8); } + let strtop = if qtop < 32 { FILTER_STRENGTH[qtop as usize] } else { 0 }; + if leftt && ctop0 { deblock_ver(buf, 0, strtop, coff); } + if ctop0 && ctop1 { deblock_ver(buf, 0, strtop, coff + 8); } } - if leftc && ccur0 { deblock_ver(buf, 0, q, off); } - if ccur0 && ccur1 { deblock_ver(buf, 0, q, off + 8); } + if leftc && ccur0 { deblock_ver(buf, 0, str, off); } + if ccur0 && ccur1 { deblock_ver(buf, 0, str, off + 8); } leftt = ctop1; leftc = ccur1; off += 16; @@ -457,8 +567,9 @@ pub fn h263_filter_row(buf: &mut NAVideoBuffer, mb_y: usize, mb_w: usize, cb let ctv = cbpi.is_coded_top(mb_x, 5); let ccv = cbpi.is_coded(mb_x, 5); let q = cbpi.get_q(mb_w + mb_x); - if ctu && ccu { deblock_hor(buf, 1, q, offu + mb_x * 8); } - if ctv && ccv { deblock_hor(buf, 2, q, offv + mb_x * 8); } + let str = if q < 32 { FILTER_STRENGTH[q as usize] } else { 0 }; + if ctu && ccu { deblock_hor(buf, 1, str, offu + mb_x * 8); } + if ctv && ccv { deblock_hor(buf, 2, str, offv + mb_x * 8); } } let mut leftu = false; let mut leftv = false; @@ -468,8 +579,9 @@ pub fn h263_filter_row(buf: &mut NAVideoBuffer, mb_y: usize, mb_w: usize, cb let ctu = cbpi.is_coded_top(mb_x, 4); let ctv = cbpi.is_coded_top(mb_x, 5); let qt = cbpi.get_q(mb_x); - if leftu && ctu { deblock_ver(buf, 1, qt, offu + mb_x * 8); } - if leftv && ctv { deblock_ver(buf, 2, qt, offv + mb_x * 8); } + let strt = if qt < 32 { FILTER_STRENGTH[qt as usize] } else { 0 }; + if leftu && ctu { deblock_ver(buf, 1, strt, offu + mb_x * 8); } + if leftv && ctv { deblock_ver(buf, 2, strt, offv + mb_x * 8); } leftu = ctu; leftv = ctv; } @@ -480,21 +592,170 @@ impl BlockDSP for H263BlockDSP { fn idct(&self, blk: &mut [i16; 64]) { h263_idct(blk) } - fn copy_blocks(&self, dst: &mut NAVideoBuffer, src: &NAVideoBuffer, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) { - let srcx = ((mv.x >> 1) as isize) + (xpos as isize); - let srcy = ((mv.y >> 1) as isize) + (ypos as isize); + fn copy_blocks(&self, dst: &mut NAVideoBuffer, src: NAVideoBufferRef, xpos: usize, ypos: usize, mv: MV) { let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize; + let cmode = (if (mv.x & 3) != 0 { 1 } else { 0 }) + (if (mv.y & 3) != 0 { 2 } else { 0 }); - blockdsp::copy_blocks(dst, src, xpos, ypos, srcx, srcy, w, h, 0, 1, mode, H263_INTERP_FUNCS); + let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap(); + + blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_FUNCS); + blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS); + blockdsp::copy_block(&mut dst, src, 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_FUNCS); } - fn avg_blocks(&self, dst: &mut NAVideoBuffer, src: &NAVideoBuffer, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) { - let srcx = ((mv.x >> 1) as isize) + (xpos as isize); - let srcy = ((mv.y >> 1) as isize) + (ypos as isize); + fn copy_blocks8x8(&self, dst: &mut NAVideoBuffer, src: NAVideoBufferRef, xpos: usize, ypos: usize, mvs: &[MV; 4]) { + let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap(); + + for i in 0..4 { + let xadd = (i & 1) * 8; + let yadd = (i & 2) * 4; + let mode = ((mvs[i].x & 1) + (mvs[i].y & 1) * 2) as usize; + + blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, H263_INTERP_FUNCS); + } + + let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3]; + let cmx = (sum_mv.x >> 3) + H263_CHROMA_ROUND[(sum_mv.x & 0xF) as usize]; + let cmy = (sum_mv.y >> 3) + H263_CHROMA_ROUND[(sum_mv.y & 0xF) as usize]; + let mode = ((cmx & 1) + (cmy & 1) * 2) as usize; + for plane in 1..3 { + blockdsp::copy_block(&mut dst, src.clone(), plane, xpos >> 1, ypos >> 1, cmx >> 1, cmy >> 1, 8, 8, 0, 1, mode, H263_INTERP_FUNCS); + } + } + fn avg_blocks(&self, dst: &mut NAVideoBuffer, src: NAVideoBufferRef, xpos: usize, ypos: usize, mv: MV) { let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize; + let cmode = (if (mv.x & 3) != 0 { 1 } else { 0 }) + (if (mv.y & 3) != 0 { 2 } else { 0 }); + + let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap(); + + blockdsp::copy_block(&mut dst, src.clone(), 0, xpos, ypos, mv.x >> 1, mv.y >> 1, 16, 16, 0, 1, mode, H263_INTERP_AVG_FUNCS); + blockdsp::copy_block(&mut dst, src.clone(), 1, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS); + blockdsp::copy_block(&mut dst, src, 2, xpos >> 1, ypos >> 1, mv.x >> 2, mv.y >> 2, 8, 8, 0, 1, cmode, H263_INTERP_AVG_FUNCS); + } + fn avg_blocks8x8(&self, dst: &mut NAVideoBuffer, src: NAVideoBufferRef, xpos: usize, ypos: usize, mvs: &[MV; 4]) { + let mut dst = NASimpleVideoFrame::from_video_buf(dst).unwrap(); - blockdsp::copy_blocks(dst, src, xpos, ypos, srcx, srcy, w, h, 0, 1, mode, H263_INTERP_AVG_FUNCS); + for i in 0..4 { + let xadd = (i & 1) * 8; + let yadd = (i & 2) * 4; + let mode = ((mvs[i].x & 1) + (mvs[i].y & 1) * 2) as usize; + + blockdsp::copy_block(&mut dst, src.clone(), 0, xpos + xadd, ypos + yadd, mvs[i].x >> 1, mvs[i].y >> 1, 8, 8, 0, 1, mode, H263_INTERP_AVG_FUNCS); + } + + let sum_mv = mvs[0] + mvs[1] + mvs[2] + mvs[3]; + let cmx = (sum_mv.x >> 3) + H263_CHROMA_ROUND[(sum_mv.x & 0xF) as usize]; + let cmy = (sum_mv.y >> 3) + H263_CHROMA_ROUND[(sum_mv.y & 0xF) as usize]; + let mode = ((cmx & 1) + (cmy & 1) * 2) as usize; + for plane in 1..3 { + blockdsp::copy_block(&mut dst, src.clone(), plane, xpos >> 1, ypos >> 1, cmx >> 1, cmy >> 1, 8, 8, 0, 1, mode, H263_INTERP_AVG_FUNCS); + } } fn filter_row(&self, buf: &mut NAVideoBuffer, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) { h263_filter_row(buf, mb_y, mb_w, cbpi) } } + +macro_rules! obmc_filter { + ($src: expr, $base_off: expr, $off0: expr, $w0: expr, $off1: expr, $w1: expr, $off2: expr, $w2: expr) => ({ + let a = $src[$base_off + $off0] as u16; + let b = $src[$base_off + $off1] as u16; + let c = $src[$base_off + $off2] as u16; + ((a * $w0 + b * $w1 + c * $w2 + 4) >> 3) as u8 + }) +} +pub fn obmc_filter(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize) { + let top_off = 8 + sstride * 0; + let left_off = 0 + sstride * 8; + let right_off = 16 + sstride * 8; + let bottom_off = 8 + sstride * 16; + let cur_off = 8 + sstride * 8; + + let mut doff = 0; + let mut soff = 0; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, top_off, 2, cur_off, 4); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 1, top_off, 2, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, top_off, 2, cur_off, 5); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, top_off, 2, cur_off, 5); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, top_off, 2, cur_off, 5); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, top_off, 2, cur_off, 5); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 1, top_off, 2, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, top_off, 2, cur_off, 4); + doff += dstride; + soff += sstride; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, top_off, 1, cur_off, 5); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 2, top_off, 1, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, top_off, 2, cur_off, 5); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, top_off, 2, cur_off, 5); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, top_off, 2, cur_off, 5); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, top_off, 2, cur_off, 5); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 2, top_off, 1, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, top_off, 1, cur_off, 5); + doff += dstride; + soff += sstride; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, top_off, 1, cur_off, 5); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 2, top_off, 1, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, top_off, 1, cur_off, 6); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, top_off, 1, cur_off, 6); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, top_off, 1, cur_off, 6); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, top_off, 1, cur_off, 6); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 2, top_off, 1, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, top_off, 1, cur_off, 5); + doff += dstride; + soff += sstride; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, top_off, 1, cur_off, 5); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 2, top_off, 1, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, top_off, 1, cur_off, 6); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, top_off, 1, cur_off, 6); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, top_off, 1, cur_off, 6); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, top_off, 1, cur_off, 6); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 2, top_off, 1, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, top_off, 1, cur_off, 5); + doff += dstride; + soff += sstride; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, bottom_off, 1, cur_off, 5); + doff += dstride; + soff += sstride; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, bottom_off, 1, cur_off, 6); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, bottom_off, 1, cur_off, 5); + doff += dstride; + soff += sstride; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 2, bottom_off, 1, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, bottom_off, 1, cur_off, 5); + doff += dstride; + soff += sstride; + + dst[doff + 0] = obmc_filter!(src, soff + 0, left_off, 2, bottom_off, 2, cur_off, 4); + dst[doff + 1] = obmc_filter!(src, soff + 1, left_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 2] = obmc_filter!(src, soff + 2, left_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 3] = obmc_filter!(src, soff + 3, left_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 4] = obmc_filter!(src, soff + 4, right_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 5] = obmc_filter!(src, soff + 5, right_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 6] = obmc_filter!(src, soff + 6, right_off, 1, bottom_off, 2, cur_off, 5); + dst[doff + 7] = obmc_filter!(src, soff + 7, right_off, 2, bottom_off, 2, cur_off, 4); +}