Commit | Line | Data |
---|---|---|
2f9923e6 KS |
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 | } |