nihav-itu/src/codecs/h264/dsp/mc/mod.rs

   1 use nihav_core::frame::*;
   2 use nihav_codec_support::codecs::MV;
   3 use nihav_codec_support::codecs::blockdsp::*;
   4
   5 #[cfg(not(debug_assertions))]
   6 mod release;
   7 #[cfg(not(debug_assertions))]
   8 use release::*;
   9 #[cfg(debug_assertions)]
  10 mod debug;
  11 #[cfg(debug_assertions)]
  12 use debug::*;
  13
  14 fn clip_u8(val: i16) -> u8 { val.max(0).min(255) as u8 }
  15
  16 pub struct H264MC {
  17     avg_buf:    NAVideoBufferRef<u8>,
  18 }
  19
  20 impl H264MC {
  21     pub fn new(avg_buf: NAVideoBufferRef<u8>) -> Self {
  22         Self {
  23             avg_buf
  24         }
  25     }
  26     pub fn do_mc(&mut self, frm: &mut NASimpleVideoFrame<u8>, refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
  27         let mut ebuf = [0u8; 22 * 22];
  28         let mvx = mv.x >> 2;
  29         let mvy = mv.y >> 2;
  30         let mode = ((mv.x & 3) + (mv.y & 3) * 4) as usize;
  31         let pre  = if mode != 0 { 2isize } else { 0 };
  32         let post = if mode != 0 { 3isize } else { 0 };
  33         let (yw, yh) = refpic.get_dimensions(0);
  34         let src = refpic.get_data();
  35         let systride = refpic.get_stride(0);
  36         let src_x = (xpos as isize) + (mvx as isize);
  37         let src_y = (ypos as isize) + (mvy as isize);
  38         let (ysrc, ystride) = if (src_x - pre < 0) || (src_x + (w as isize) + post > (yw as isize)) || (src_y - pre < 0) || (src_y + (h as isize) + post > (yh as isize)) {
  39                 let add = (pre + post) as usize;
  40                 edge_emu(&refpic, src_x - pre, src_y - pre, w + add, h + add, &mut ebuf, 22, 0, 0);
  41                 (ebuf.as_slice(), 22)
  42             } else {
  43                 (&src[refpic.get_offset(0) + ((src_x - pre) as usize) + ((src_y - pre) as usize) * systride..], systride)
  44             };
  45         (H264_LUMA_INTERP[mode])(&mut frm.data[frm.offset[0] + xpos + ypos * frm.stride[0]..], frm.stride[0], ysrc, ystride, w, h);
  46
  47         let (cw, ch) = refpic.get_dimensions(1);
  48         let mvx = mv.x >> 3;
  49         let mvy = mv.y >> 3;
  50         let dx = (mv.x & 7) as u16;
  51         let dy = (mv.y & 7) as u16;
  52         let src_x = ((xpos >> 1) as isize) + (mvx as isize);
  53         let src_y = ((ypos >> 1) as isize) + (mvy as isize);
  54         let suoff = refpic.get_offset(1);
  55         let svoff = refpic.get_offset(2);
  56         let sustride = refpic.get_stride(1);
  57         let svstride = refpic.get_stride(2);
  58         let cbw = w / 2;
  59         let cbh = h / 2;
  60         let (csrc, cstride) = if (src_x < 0) || (src_x + (cbw as isize) + 1 > (cw as isize)) || (src_y < 0) || (src_y + (cbh as isize) + 1 > (ch as isize)) {
  61                 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf,      18, 1, 4);
  62                 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf[9..], 18, 2, 4);
  63                 ([&ebuf, &ebuf[9..]], [18, 18])
  64             } else {
  65                 ([&src[suoff + (src_x as usize) + (src_y as usize) * sustride..],
  66                  &src[svoff + (src_x as usize) + (src_y as usize) * svstride..]],
  67                  [sustride, svstride])
  68             };
  69         for chroma in 1..3 {
  70             let off = frm.offset[chroma] + xpos / 2 + (ypos / 2) * frm.stride[chroma];
  71             chroma_interp(&mut frm.data[off..], frm.stride[chroma], csrc[chroma - 1], cstride[chroma - 1], dx, dy, cbw, cbh);
  72         }
  73     }
  74
  75     pub fn mc_blocks(&mut self, ydst: &mut [u8], udst: &mut [u8], vdst: &mut [u8], refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
  76         let mode = ((mv.x & 3) + (mv.y & 3) * 4) as usize;
  77
  78         let pre  = if mode != 0 { 2 } else { 0 };
  79         let post = if mode != 0 { 3 } else { 0 };
  80         let (width, height) = refpic.get_dimensions(0);
  81         let sx = (xpos as isize) + ((mv.x >> 2) as isize);
  82         let sy = (ypos as isize) + ((mv.y >> 2) as isize);
  83
  84         const EBUF_STRIDE: usize = 32;
  85         let mut ebuf = [0u8; EBUF_STRIDE * (16 + 2 + 3)];
  86
  87         if (sx - pre < 0) || (sx + (w as isize) + post > (width as isize)) ||
  88            (sy - pre < 0) || (sy + (h as isize) + post > (height as isize)) {
  89             let edge = (pre + post) as usize;
  90             edge_emu(&refpic, sx - pre, sy - pre, w + edge, h + edge,
  91                      &mut ebuf, EBUF_STRIDE, 0, 0);
  92             (H264_LUMA_INTERP[mode])(ydst, 16, &ebuf, EBUF_STRIDE, w, h);
  93         } else {
  94             let sstride = refpic.get_stride(0);
  95             let soff    = refpic.get_offset(0);
  96             let sdta    = refpic.get_data();
  97             let sbuf: &[u8] = sdta.as_slice();
  98             let saddr = soff + ((sx - pre) as usize) + ((sy - pre) as usize) * sstride;
  99             (H264_LUMA_INTERP[mode])(ydst, 16, &sbuf[saddr..], sstride, w, h);
 100         }
 101
 102         let (cw, ch) = refpic.get_dimensions(1);
 103         let mvx = mv.x >> 3;
 104         let mvy = mv.y >> 3;
 105         let dx = (mv.x & 7) as u16;
 106         let dy = (mv.y & 7) as u16;
 107         let src_x = ((xpos >> 1) as isize) + (mvx as isize);
 108         let src_y = ((ypos >> 1) as isize) + (mvy as isize);
 109         let suoff = refpic.get_offset(1);
 110         let svoff = refpic.get_offset(2);
 111         let sustride = refpic.get_stride(1);
 112         let svstride = refpic.get_stride(2);
 113         let src = refpic.get_data();
 114         let cbw = w / 2;
 115         let cbh = h / 2;
 116         let (csrc, cstride) = if (src_x < 0) || (src_x + (cbw as isize) + 1 > (cw as isize)) || (src_y < 0) || (src_y + (cbh as isize) + 1 > (ch as isize)) {
 117                 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf,      18, 1, 4);
 118                 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf[9..], 18, 2, 4);
 119                 ([&ebuf, &ebuf[9..]], [18, 18])
 120             } else {
 121                 ([&src[suoff + (src_x as usize) + (src_y as usize) * sustride..],
 122                  &src[svoff + (src_x as usize) + (src_y as usize) * svstride..]],
 123                  [sustride, svstride])
 124             };
 125         chroma_interp(udst, 16, csrc[0], cstride[0], dx, dy, cbw, cbh);
 126         chroma_interp(vdst, 16, csrc[1], cstride[1], dx, dy, cbw, cbh);
 127     }
 128
 129     pub fn avg(&mut self, dst: &mut [u8], dstride: usize, bw: usize, bh: usize, comp: usize) {
 130         let afrm = NASimpleVideoFrame::from_video_buf(&mut self.avg_buf).unwrap();
 131         let src = &afrm.data[afrm.offset[comp]..];
 132         let sstride = afrm.stride[comp];
 133         for (dline, sline) in dst.chunks_mut(dstride).zip(src.chunks(sstride)).take(bh) {
 134             for (dst, src) in dline.iter_mut().zip(sline.iter()).take(bw) {
 135                 *dst = ((u16::from(*dst) + u16::from(*src) + 1) >> 1) as u8;
 136             }
 137         }
 138     }
 139
 140     pub fn do_mc_avg(&mut self, frm: &mut NASimpleVideoFrame<u8>, refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
 141         let mut abuf = self.avg_buf.clone();
 142         let mut afrm = NASimpleVideoFrame::from_video_buf(&mut abuf).unwrap();
 143         let amv = MV { x: mv.x + (xpos as i16) * 4, y: mv.y + (ypos as i16) * 4 };
 144         self.do_mc(&mut afrm, refpic, 0, 0, w, h, amv);
 145         for comp in 0..3 {
 146             let shift = if comp == 0 { 0 } else { 1 };
 147             self.avg(&mut frm.data[frm.offset[comp] + (xpos >> shift) + (ypos >> shift) * frm.stride[comp]..], frm.stride[comp], w >> shift, h >> shift, comp);
 148         }
 149     }
 150
 151     pub fn put_block_weighted(&mut self, dst: &mut [u8], stride: usize, src: &[u8], w: usize, h: usize, wparams: [i8; 3]) {
 152         let weight = i16::from(wparams[0]);
 153         let offset = i16::from(wparams[1]);
 154         let wshift = wparams[2] as u8;
 155         let bias = (1 << wshift) >> 1;
 156
 157         for (drow, srow) in dst.chunks_mut(stride).zip(src.chunks(16)).take(h) {
 158             for (dst, &src) in drow[..w].iter_mut().zip(srow.iter()) {
 159                 *dst = clip_u8(((i16::from(src) * weight + bias) >> wshift) + offset);
 160             }
 161         }
 162     }
 163
 164     pub fn put_block_weighted2(&mut self, dst: &mut [u8], stride: usize, src0: &[u8], src1: &[u8], w: usize, h: usize, wparams: [i8; 5]) {
 165         let weight0 = i16::from(wparams[0]);
 166         let offset0 = i16::from(wparams[1]);
 167         let weight1 = i16::from(wparams[2]);
 168         let offset1 = i16::from(wparams[3]);
 169         let wshift = (wparams[4] as u8) + 1;
 170         let offset = (offset0 + offset1 + 1) >> 1;
 171         let bias = (1 << wshift) >> 1;
 172
 173         for (drow, (srow0, srow1)) in dst.chunks_mut(stride).zip(src0.chunks(16).zip(src1.chunks(16))).take(h) {
 174             for (dst, (&src0, &src1)) in drow[..w].iter_mut().zip(srow0.iter().zip(srow1.iter())) {
 175                 *dst = clip_u8(((i16::from(src0) * weight0 + i16::from(src1) * weight1 + bias) >> wshift) + offset);
 176             }
 177         }
 178     }
 179
 180     pub fn gray_block(&mut self, frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, w: usize, h: usize) {
 181         let yoff = frm.offset[0] + x + y * frm.stride[0];
 182         let coff = [frm.offset[1] + x / 2 + y / 2 * frm.stride[1],
 183                     frm.offset[2] + x / 2 + y / 2 * frm.stride[2]];
 184         for row in frm.data[yoff..].chunks_mut(frm.stride[0]).take(h) {
 185             for el in row[..w].iter_mut() {
 186                 *el = 128;
 187             }
 188         }
 189         for chroma in 0..2 {
 190             for row in frm.data[coff[chroma]..].chunks_mut(frm.stride[chroma + 1]).take(h / 2) {
 191                 for el in row[..w / 2].iter_mut() {
 192                     *el = 128;
 193                 }
 194             }
 195         }
 196     }
 197 }