1 use nihav_core::frame::*;
2 use nihav_codec_support::codecs::blockdsp::edge_emu;
4 fn clip_u8(val: i16) -> u8 {
5 val.max(0).min(255) as u8
8 pub struct IPredContext {
17 pub fn fill(&mut self, src: &[u8], off: usize, stride: usize, tsize: usize, lsize: usize) {
20 self.top[i] = src[off - stride + i];
26 self.top = [0x80; 16];
30 self.left[i] = src[off - 1 + i * stride];
36 self.left = [0x80; 16];
38 if self.has_top && self.has_left {
39 self.tl = src[off - stride - 1];
46 impl Default for IPredContext {
47 fn default() -> Self {
58 pub fn add_coeffs4x4(dst: &mut [u8], off: usize, stride: usize, coeffs: &[i16; 16]) {
59 let dst = &mut dst[off..];
60 for (out, src) in dst.chunks_mut(stride).zip(coeffs.chunks(4)) {
61 for (oel, iel) in out.iter_mut().take(4).zip(src.iter()) {
62 *oel = clip_u8(i16::from(*oel) + *iel);
66 pub fn add_coeffs16x1(dst: &mut [u8], off: usize, coeffs: &[i16; 16]) {
67 let dst = &mut dst[off..];
68 for (oel, iel) in dst.iter_mut().take(16).zip(coeffs.iter()) {
69 *oel = clip_u8(i16::from(*oel) + *iel);
75 fn ipred_dc(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
77 if !ipred.has_left && !ipred.has_top {
81 let mut dcshift = match Self::SIZE {
86 for el in ipred.left.iter().take(Self::SIZE) {
87 dcsum += u16::from(*el);
92 for el in ipred.top.iter().take(Self::SIZE) {
93 dcsum += u16::from(*el);
97 dc = ((dcsum + (1 << (dcshift - 1))) >> dcshift) as u8;
99 for _ in 0..Self::SIZE {
100 let out = &mut dst[off..][..Self::SIZE];
101 for el in out.iter_mut() {
107 fn ipred_v(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
108 for _ in 0..Self::SIZE {
109 let out = &mut dst[off..][..Self::SIZE];
110 out.copy_from_slice(&ipred.top[0..Self::SIZE]);
114 fn ipred_h(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
115 for leftel in ipred.left.iter().take(Self::SIZE) {
116 let out = &mut dst[off..][..Self::SIZE];
117 for el in out.iter_mut() {
123 fn ipred_tm(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
124 let tl = i16::from(ipred.tl);
125 for m in 0..Self::SIZE {
126 for n in 0..Self::SIZE {
127 dst[off + n] = clip_u8(i16::from(ipred.left[m]) + i16::from(ipred.top[n]) - tl);
134 pub struct IPred16x16 {}
135 impl IntraPred for IPred16x16 { const SIZE: usize = 16; }
137 pub struct IPred8x8 {}
138 impl IntraPred for IPred8x8 { const SIZE: usize = 8; }
140 macro_rules! load_pred4 {
141 (topleft; $ipred: expr) => {{
142 let tl = u16::from($ipred.tl);
143 let a0 = u16::from($ipred.top[0]);
144 let l0 = u16::from($ipred.left[0]);
145 ((l0 + tl * 2 + a0 + 2) >> 2) as u8
147 (top; $ipred: expr) => {{
148 let tl = u16::from($ipred.tl);
149 let a0 = u16::from($ipred.top[0]);
150 let a1 = u16::from($ipred.top[1]);
151 let a2 = u16::from($ipred.top[2]);
152 let a3 = u16::from($ipred.top[3]);
153 let a4 = u16::from($ipred.top[4]);
154 let p0 = ((tl + a0 * 2 + a1 + 2) >> 2) as u8;
155 let p1 = ((a0 + a1 * 2 + a2 + 2) >> 2) as u8;
156 let p2 = ((a1 + a2 * 2 + a3 + 2) >> 2) as u8;
157 let p3 = ((a2 + a3 * 2 + a4 + 2) >> 2) as u8;
160 (top8; $ipred: expr) => {{
161 let t3 = u16::from($ipred.top[3]);
162 let t4 = u16::from($ipred.top[4]);
163 let t5 = u16::from($ipred.top[5]);
164 let t6 = u16::from($ipred.top[6]);
165 let t7 = u16::from($ipred.top[7]);
166 let p4 = ((t3 + t4 * 2 + t5 + 2) >> 2) as u8;
167 let p5 = ((t4 + t5 * 2 + t6 + 2) >> 2) as u8;
168 let p6 = ((t5 + t6 * 2 + t7 + 2) >> 2) as u8;
169 let p7 = ((t6 + t7 * 2 + t7 + 2) >> 2) as u8;
172 (topavg; $ipred: expr) => {{
173 let tl = u16::from($ipred.tl);
174 let a0 = u16::from($ipred.top[0]);
175 let a1 = u16::from($ipred.top[1]);
176 let a2 = u16::from($ipred.top[2]);
177 let a3 = u16::from($ipred.top[3]);
178 let p0 = ((tl + a0 + 1) >> 1) as u8;
179 let p1 = ((a0 + a1 + 1) >> 1) as u8;
180 let p2 = ((a1 + a2 + 1) >> 1) as u8;
181 let p3 = ((a2 + a3 + 1) >> 1) as u8;
184 (left; $ipred: expr) => {{
185 let tl = u16::from($ipred.tl);
186 let l0 = u16::from($ipred.left[0]);
187 let l1 = u16::from($ipred.left[1]);
188 let l2 = u16::from($ipred.left[2]);
189 let l3 = u16::from($ipred.left[3]);
190 let l4 = u16::from($ipred.left[4]);
191 let p0 = ((tl + l0 * 2 + l1 + 2) >> 2) as u8;
192 let p1 = ((l0 + l1 * 2 + l2 + 2) >> 2) as u8;
193 let p2 = ((l1 + l2 * 2 + l3 + 2) >> 2) as u8;
194 let p3 = ((l2 + l3 * 2 + l4 + 2) >> 2) as u8;
197 (left8; $ipred: expr) => {{
198 let l3 = u16::from($ipred.left[3]);
199 let l4 = u16::from($ipred.left[4]);
200 let l5 = u16::from($ipred.left[5]);
201 let l6 = u16::from($ipred.left[6]);
202 let l7 = u16::from($ipred.left[7]);
203 let p4 = ((l3 + l4 * 2 + l5 + 2) >> 2) as u8;
204 let p5 = ((l4 + l5 * 2 + l6 + 2) >> 2) as u8;
205 let p6 = ((l5 + l6 * 2 + l7 + 2) >> 2) as u8;
206 let p7 = ((l6 + l7 * 2 + l7 + 2) >> 2) as u8;
209 (leftavg; $ipred: expr) => {{
210 let tl = u16::from($ipred.tl);
211 let l0 = u16::from($ipred.left[0]);
212 let l1 = u16::from($ipred.left[1]);
213 let l2 = u16::from($ipred.left[2]);
214 let l3 = u16::from($ipred.left[3]);
215 let p0 = ((tl + l0 + 1) >> 1) as u8;
216 let p1 = ((l0 + l1 + 1) >> 1) as u8;
217 let p2 = ((l1 + l2 + 1) >> 1) as u8;
218 let p3 = ((l2 + l3 + 1) >> 1) as u8;
223 pub struct IPred4x4 {}
225 pub fn ipred_dc(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
228 for el in ipred.left.iter().take(4) {
229 dcsum += u16::from(*el);
231 for el in ipred.top.iter().take(4) {
232 dcsum += u16::from(*el);
234 dc = ((dcsum + (1 << 2)) >> 3) as u8;
236 let out = &mut dst[off..][..4];
237 for el in out.iter_mut() {
243 pub fn ipred_tm(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
244 let tl = i16::from(ipred.tl);
247 dst[off + n] = clip_u8(i16::from(ipred.left[m]) + i16::from(ipred.top[n]) - tl);
252 pub fn ipred_ve(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
253 let (v0, v1, v2, v3) = load_pred4!(top; ipred);
254 let vert_pred = [v0, v1, v2, v3];
256 let out = &mut dst[off..][..4];
257 out.copy_from_slice(&vert_pred);
261 pub fn ipred_he(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
262 let (p0, p1, p2, _) = load_pred4!(left; ipred);
263 let p3 = ((u16::from(ipred.left[2]) + u16::from(ipred.left[3]) * 3 + 2) >> 2) as u8;
264 let hor_pred = [p0, p1, p2, p3];
267 dst[off + n] = hor_pred[m];
272 pub fn ipred_ld(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
273 let (_, p0, p1, p2) = load_pred4!(top; ipred);
274 let (p3, p4, p5, p6) = load_pred4!(top8; ipred);
276 dst[off + 0] = p0; dst[off + 1] = p1; dst[off + 2] = p2; dst[off + 3] = p3;
278 dst[off + 0] = p1; dst[off + 1] = p2; dst[off + 2] = p3; dst[off + 3] = p4;
280 dst[off + 0] = p2; dst[off + 1] = p3; dst[off + 2] = p4; dst[off + 3] = p5;
282 dst[off + 0] = p3; dst[off + 1] = p4; dst[off + 2] = p5; dst[off + 3] = p6;
284 pub fn ipred_rd(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
285 let tl = load_pred4!(topleft; ipred);
286 let (l0, l1, l2, _) = load_pred4!(left; ipred);
287 let (t0, t1, t2, _) = load_pred4!(top; ipred);
289 dst[off + 0] = tl; dst[off + 1] = t0; dst[off + 2] = t1; dst[off + 3] = t2;
291 dst[off + 0] = l0; dst[off + 1] = tl; dst[off + 2] = t0; dst[off + 3] = t1;
293 dst[off + 0] = l1; dst[off + 1] = l0; dst[off + 2] = tl; dst[off + 3] = t0;
295 dst[off + 0] = l2; dst[off + 1] = l1; dst[off + 2] = l0; dst[off + 3] = tl;
297 pub fn ipred_vr(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
298 let tl = load_pred4!(topleft; ipred);
299 let (l0, l1, _, _) = load_pred4!(left; ipred);
300 let (t0, t1, t2, _) = load_pred4!(top; ipred);
301 let (m0, m1, m2, m3) = load_pred4!(topavg; ipred);
303 dst[off + 0] = m0; dst[off + 1] = m1; dst[off + 2] = m2; dst[off + 3] = m3;
305 dst[off + 0] = tl; dst[off + 1] = t0; dst[off + 2] = t1; dst[off + 3] = t2;
307 dst[off + 0] = l0; dst[off + 1] = m0; dst[off + 2] = m1; dst[off + 3] = m2;
309 dst[off + 0] = l1; dst[off + 1] = tl; dst[off + 2] = t0; dst[off + 3] = t1;
311 pub fn ipred_vl(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
312 let (_, t1, t2, t3) = load_pred4!(top; ipred);
313 let (t4, t5, t6, _) = load_pred4!(top8; ipred);
314 let (_, m1, m2, m3) = load_pred4!(topavg; ipred);
315 let m4 = ((u16::from(ipred.top[3]) + u16::from(ipred.top[4]) + 1) >> 1) as u8;
317 dst[off + 0] = m1; dst[off + 1] = m2; dst[off + 2] = m3; dst[off + 3] = m4;
319 dst[off + 0] = t1; dst[off + 1] = t2; dst[off + 2] = t3; dst[off + 3] = t4;
321 dst[off + 0] = m2; dst[off + 1] = m3; dst[off + 2] = m4; dst[off + 3] = t5;
323 dst[off + 0] = t2; dst[off + 1] = t3; dst[off + 2] = t4; dst[off + 3] = t6;
325 pub fn ipred_hd(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
326 let tl = load_pred4!(topleft; ipred);
327 let (l0, l1, l2, _) = load_pred4!(left; ipred);
328 let (m0, m1, m2, m3) = load_pred4!(leftavg; ipred);
329 let (t0, t1, _, _) = load_pred4!(top; ipred);
331 dst[off + 0] = m0; dst[off + 1] = tl; dst[off + 2] = t0; dst[off + 3] = t1;
333 dst[off + 0] = m1; dst[off + 1] = l0; dst[off + 2] = m0; dst[off + 3] = tl;
335 dst[off + 0] = m2; dst[off + 1] = l1; dst[off + 2] = m1; dst[off + 3] = l0;
337 dst[off + 0] = m3; dst[off + 1] = l2; dst[off + 2] = m2; dst[off + 3] = l1;
339 pub fn ipred_hu(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
340 let (_, m1, m2, m3) = load_pred4!(leftavg; ipred);
341 let (_, l1, l2, _) = load_pred4!(left; ipred);
342 let l3 = ((u16::from(ipred.left[2]) + u16::from(ipred.left[3]) * 3 + 2) >> 2) as u8;
343 let p3 = ipred.left[3];
345 dst[off + 0] = m1; dst[off + 1] = l1; dst[off + 2] = m2; dst[off + 3] = l2;
347 dst[off + 0] = m2; dst[off + 1] = l2; dst[off + 2] = m3; dst[off + 3] = l3;
349 dst[off + 0] = m3; dst[off + 1] = l3; dst[off + 2] = p3; dst[off + 3] = p3;
351 dst[off + 0] = p3; dst[off + 1] = p3; dst[off + 2] = p3; dst[off + 3] = p3;
355 const VP7_BICUBIC_FILTERS: [[i16; 6]; 8] = [
356 [ 0, 0, 128, 0, 0, 0 ],
357 [ 0, -6, 123, 12, -1, 0 ],
358 [ 2, -11, 108, 36, -8, 1 ],
359 [ 0, -9, 93, 50, -6, 0 ],
360 [ 3, -16, 77, 77, -16, 3 ],
361 [ 0, -6, 50, 93, -9, 0 ],
362 [ 1, -8, 36, 108, -11, 2 ],
363 [ 0, -1, 12, 123, -6, 0 ]
366 macro_rules! interpolate {
367 ($src: expr, $off: expr, $step: expr, $mode: expr) => {{
368 let s0 = i32::from($src[$off + 0 * $step]);
369 let s1 = i32::from($src[$off + 1 * $step]);
370 let s2 = i32::from($src[$off + 2 * $step]);
371 let s3 = i32::from($src[$off + 3 * $step]);
372 let s4 = i32::from($src[$off + 4 * $step]);
373 let s5 = i32::from($src[$off + 5 * $step]);
374 let filt = &VP7_BICUBIC_FILTERS[$mode];
375 let src = [s0, s1, s2, s3, s4, s5];
377 for (s, c) in src.iter().zip(filt.iter()) {
378 val += s * i32::from(*c);
380 clip_u8((val >> 7) as i16)
384 const EDGE_PRE: usize = 2;
385 const EDGE_POST: usize = 4;
386 const TMP_STRIDE: usize = 16;
388 fn mc_block_common(dst: &mut [u8], mut doff: usize, dstride: usize, src: &[u8], sstride: usize, size: usize, mx: usize, my: usize) {
389 if (mx == 0) && (my == 0) {
390 let dst = &mut dst[doff..];
391 let src = &src[EDGE_PRE + EDGE_PRE * sstride..];
392 for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
393 (&mut out[0..size]).copy_from_slice(&src[0..size]);
396 let src = &src[EDGE_PRE * sstride..];
397 for src in src.chunks(sstride).take(size) {
399 dst[doff + x] = interpolate!(src, x, 1, mx);
404 let src = &src[EDGE_PRE..];
407 dst[doff + x] = interpolate!(src, x + y * sstride, sstride, my);
412 let mut tmp = [0u8; TMP_STRIDE * (16 + EDGE_PRE + EDGE_POST)];
413 for (y, dst) in tmp.chunks_mut(TMP_STRIDE).take(size + EDGE_PRE + EDGE_POST).enumerate() {
415 dst[x] = interpolate!(src, x + y * sstride, 1, mx);
420 dst[doff + x] = interpolate!(tmp, x + y * TMP_STRIDE, TMP_STRIDE, my);
426 fn mc_block(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
427 mvx: i16, mvy: i16, reffrm: NAVideoBufferRef<u8>, plane: usize,
428 mc_buf: &mut [u8], size: usize) {
429 if (mvx == 0) && (mvy == 0) {
430 let dst = &mut dst[doff..];
431 let sstride = reffrm.get_stride(plane);
432 let srcoff = reffrm.get_offset(plane) + xpos + ypos * sstride;
433 let src = &reffrm.get_data();
434 let src = &src[srcoff..];
435 for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
436 (&mut out[0..size]).copy_from_slice(&src[0..size]);
440 let (w, h) = reffrm.get_dimensions(plane);
441 let wa = if plane == 0 { (w + 15) & !15 } else { (w + 7) & !7 } as isize;
442 let ha = if plane == 0 { (h + 15) & !15 } else { (h + 7) & !7 } as isize;
443 let bsize = (size as isize) + (EDGE_PRE as isize) + (EDGE_POST as isize);
444 let ref_x = (xpos as isize) + ((mvx >> 3) as isize) - (EDGE_PRE as isize);
445 let ref_y = (ypos as isize) + ((mvy >> 3) as isize) - (EDGE_PRE as isize);
447 let (src, sstride) = if (ref_x < 0) || (ref_x + bsize > wa) || (ref_y < 0) || (ref_y + bsize > ha) {
448 edge_emu(&reffrm, ref_x, ref_y, bsize as usize, bsize as usize, mc_buf, 32, plane, 4);
449 (mc_buf as &[u8], 32)
451 let off = reffrm.get_offset(plane);
452 let stride = reffrm.get_stride(plane);
453 let data = reffrm.get_data();
454 (&data[off + (ref_x as usize) + (ref_y as usize) * stride..], stride)
456 let mx = (mvx & 7) as usize;
457 let my = (mvy & 7) as usize;
458 mc_block_common(dst, doff, dstride, src, sstride, size, mx, my);
460 pub fn mc_block16x16(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
461 mvx: i16, mvy: i16, src: NAVideoBufferRef<u8>, plane: usize, mc_buf: &mut [u8]) {
462 mc_block(dst, doff, dstride, xpos, ypos, mvx, mvy, src, plane, mc_buf, 16);
464 pub fn mc_block8x8(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
465 mvx: i16, mvy: i16, src: NAVideoBufferRef<u8>, plane: usize, mc_buf: &mut [u8]) {
466 mc_block(dst, doff, dstride, xpos, ypos, mvx, mvy, src, plane, mc_buf, 8);
468 pub fn mc_block4x4(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
469 mvx: i16, mvy: i16, src: NAVideoBufferRef<u8>, plane: usize, mc_buf: &mut [u8]) {
470 mc_block(dst, doff, dstride, xpos, ypos, mvx, mvy, src, plane, mc_buf, 4);
472 pub fn mc_block_special(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
473 mvx: i16, mvy: i16, reffrm: NAVideoBufferRef<u8>, plane: usize,
474 mc_buf: &mut [u8], size: usize, pitch_mode: u8) {
475 const Y_MUL: [isize; 8] = [ 1, 0, 2, 4, 1, 1, 2, 2 ];
476 const Y_OFF: [isize; 8] = [ 0, 4, 0, 0, 1, -1, 1, -1 ];
477 const ILACE_CHROMA: [bool; 8] = [ false, false, true, true, false, false, true, true ]; // mode&2 != 0
479 let pitch_mode = (pitch_mode & 7) as usize;
480 let (xstep, ymul) = if plane == 0 {
481 (Y_OFF[pitch_mode], Y_MUL[pitch_mode])
483 (0, if ILACE_CHROMA[pitch_mode] { 2 } else { 1 })
486 let (w, h) = reffrm.get_dimensions(plane);
487 let wa = if plane == 0 { (w + 15) & !15 } else { (w + 7) & !7 } as isize;
488 let ha = if plane == 0 { (h + 15) & !15 } else { (h + 7) & !7 } as isize;
489 let mut start_x = (xpos as isize) + ((mvx >> 3) as isize) - (EDGE_PRE as isize);
490 let mut end_x = (xpos as isize) + ((mvx >> 3) as isize) + ((size + EDGE_POST) as isize);
492 start_x -= (size + EDGE_POST) as isize;
493 } else if xstep > 0 {
494 end_x += (size as isize) * xstep;
496 let mut start_y = (ypos as isize) + ((mvy >> 3) as isize) - (EDGE_PRE as isize) * ymul;
497 let mut end_y = (ypos as isize) + ((mvy >> 3) as isize) + ((size + EDGE_POST) as isize) * ymul;
499 start_y -= EDGE_PRE as isize;
500 end_y += (EDGE_POST + 1) as isize;
502 let off = reffrm.get_offset(plane);
503 let stride = reffrm.get_stride(plane);
504 let (src, sstride) = if (start_x >= 0) && (end_x <= wa) && (start_y >= 0) && (end_y <= ha) {
505 let data = reffrm.get_data();
506 (&data[off + (start_x as usize) + (start_y as usize) * stride..],
507 ((stride as isize) + xstep) as usize)
509 let add = (size + EDGE_PRE + EDGE_POST) * (xstep.abs() as usize);
510 let bw = size + EDGE_PRE + EDGE_POST + add;
511 let bh = (end_y - start_y) as usize;
512 let bo = if xstep >= 0 { 0 } else { add };
513 edge_emu(&reffrm, start_x + (bo as isize), start_y, bw, bh, mc_buf, 128, plane, 0);
514 (&mc_buf[bo..], (128 + xstep) as usize)
516 let mx = (mvx & 7) as usize;
517 let my = (mvy & 7) as usize;
519 0 => unimplemented!(),
520 1 => mc_block_common(dst, doff, dstride, src, sstride, size, mx, my),
522 let hsize = size / 2;
525 mc_block_common(dst, doff + x * hsize + y * hsize * dstride, dstride,
526 &src[x * hsize + y * sstride..], sstride * 2, hsize, mx, my);
531 let qsize = size / 4;
534 mc_block_common(dst, doff + x * qsize + y * qsize * dstride, dstride,
535 &src[x * qsize + y * sstride..], sstride * 4, qsize, mx, my);