h264: reduce number of arguments for mc_blocks()

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

diff --git a/nihav-itu/src/codecs/h264/dsp/mc/mod.rs b/nihav-itu/src/codecs/h264/dsp/mc/mod.rs
index ca4e77f5728764339ff8e3552594166591e057f9..19f2f28a39bc8fa611d1fa7fda97d31eea68d3a7 100644 (file)
--- a/nihav-itu/src/codecs/h264/dsp/mc/mod.rs
+++ b/nihav-itu/src/codecs/h264/dsp/mc/mod.rs
@@ -2,14 +2,31 @@ use nihav_core::frame::*;
 use nihav_codec_support::codecs::MV;
 use nihav_codec_support::codecs::blockdsp::*;
 
-#[cfg(not(debug_assertions))]
-mod release;
-#[cfg(not(debug_assertions))]
-use release::*;
-#[cfg(debug_assertions)]
-mod debug;
-#[cfg(debug_assertions)]
-use debug::*;
+macro_rules! module_selector {
+    ($( ($cond:meta, $module:ident) ),*) => {
+        module_selector!(list; r#false; $(($cond, $module)),*);
+    };
+    (list; $nocond:meta; ($ccar:meta, $carmod:ident), $(($condcdr:meta, $cdrmod:ident)),*) => {
+        module_selector!(single; $nocond; $ccar; $carmod);
+        module_selector!(list; any($nocond, $ccar); $(($condcdr, $cdrmod)),*);
+    };
+    (list; $nocond:meta; ($yescond:meta, $module:ident)) => {
+        module_selector!(single; $nocond; $yescond; $module);
+    };
+    (list; $_:meta; ) => {};
+    (single; $nocond:meta; $yescond:meta; $module:ident) => {
+        #[cfg(all(not($nocond), $yescond))]
+        mod $module;
+        #[cfg(all(not($nocond), $yescond))]
+        use $module::*;
+    };
+}
+
+module_selector! (
+    (all(feature = "simd", target_arch = "x86_64"), x86),
+    (debug_assertions, debug),
+    (not(debug_assertions), release)
+);
 
 type MCFunc = fn (dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, h: usize);
 
@@ -19,6 +36,23 @@ trait RegisterSIMD {
     fn register_simd(&mut self);
 }
 
+#[repr(align(16))]
+pub struct McBlock {
+    pub y:  [u8; 16 * 16],
+    pub u:  [u8; 16 * 16],
+    pub v:  [u8; 16 * 16],
+}
+
+impl McBlock {
+    pub fn new() -> Self {
+        unsafe {
+            let blk = std::mem::MaybeUninit::uninit();
+            blk.assume_init()
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
 pub struct H264MC {
     avg_buf:    NAVideoBufferRef<u8>,
     pub put_block_weighted:     [fn (dst: &mut [u8], stride: usize, src: &[u8], h: usize, wparams: [i8; 3]); 4],
@@ -62,7 +96,7 @@ impl H264MC {
         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)) {
                 let add = (pre + post) as usize;
                 edge_emu(&refpic, src_x - pre, src_y - pre, w + add, h + add, &mut ebuf, 22, 0, 0);
-                (ebuf.as_slice(), 22)
+                (&ebuf[..], 22)
             } else {
                 (&src[refpic.get_offset(0) + ((src_x - pre) as usize) + ((src_y - pre) as usize) * systride..], systride)
             };
@@ -101,7 +135,7 @@ impl H264MC {
         }
     }
 
-    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) {
+    pub fn mc_blocks(&mut self, dst: &mut McBlock, refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
         let mode = ((mv.x & 3) + (mv.y & 3) * 4) as usize;
 
         let pre  = if mode != 0 { 2 } else { 0 };
@@ -123,14 +157,14 @@ impl H264MC {
             let edge = (pre + post) as usize;
             edge_emu(&refpic, sx - pre, sy - pre, w + edge, h + edge,
                      &mut ebuf, EBUF_STRIDE, 0, 0);
-            (H264_LUMA_INTERP[wmode][mode])(ydst, 16, &ebuf, EBUF_STRIDE, h);
+            (H264_LUMA_INTERP[wmode][mode])(&mut dst.y, 16, &ebuf, EBUF_STRIDE, h);
         } else {
             let sstride = refpic.get_stride(0);
             let soff    = refpic.get_offset(0);
             let sdta    = refpic.get_data();
             let sbuf: &[u8] = sdta.as_slice();
             let saddr = soff + ((sx - pre) as usize) + ((sy - pre) as usize) * sstride;
-            (H264_LUMA_INTERP[wmode][mode])(ydst, 16, &sbuf[saddr..], sstride, h);
+            (H264_LUMA_INTERP[wmode][mode])(&mut dst.y, 16, &sbuf[saddr..], sstride, h);
         }
 
         let (cw, ch) = (self.width >> 1, self.height >> 1);
@@ -156,8 +190,8 @@ impl H264MC {
                  &src[svoff + (src_x as usize) + (src_y as usize) * svstride..]],
                  [sustride, svstride])
             };
-        (self.chroma_interp[wmode])(udst, 16, csrc[0], cstride[0], dx, dy, cbh);
-        (self.chroma_interp[wmode])(vdst, 16, csrc[1], cstride[1], dx, dy, cbh);
+        (self.chroma_interp[wmode])(&mut dst.u, 16, csrc[0], cstride[0], dx, dy, cbh);
+        (self.chroma_interp[wmode])(&mut dst.v, 16, csrc[1], cstride[1], dx, dy, cbh);
     }
 
     pub fn do_mc_avg(&mut self, frm: &mut NASimpleVideoFrame<u8>, refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {