1 use nihav_core::frame::*;
2 use nihav_codec_support::codecs::blockdsp::*;
3 use nihav_codec_support::codecs::MV;
5 #[cfg(not(debug_assertions))]
7 #[cfg(not(debug_assertions))]
9 #[cfg(debug_assertions)]
11 #[cfg(debug_assertions)]
14 pub const CHROMA_QUANTS: [u8; 52] = [
15 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 29, 30,
17 31, 32, 32, 33, 34, 34, 35, 35, 36, 36, 37, 37, 37, 38, 38, 38,
21 pub const CHROMA_DC_SCAN: [usize; 4] = [ 0, 1, 2, 3];
22 pub const ZIGZAG: [usize; 16] = [
23 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
25 pub const ZIGZAG1: [usize; 15] = [
26 0, 3, 7, 4, 1, 2, 5, 8, 11, 12, 9, 6, 10, 13, 14
28 /*pub const IL_SCAN: [usize; 16] = [
29 0, 4, 1, 8, 12, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15
31 pub const ZIGZAG8X8: [usize; 64] = [
32 0, 1, 8, 16, 9, 2, 3, 10,
33 17, 24, 32, 25, 18, 11, 4, 5,
34 12, 19, 26, 33, 40, 48, 41, 34,
35 27, 20, 13, 6, 7, 14, 21, 28,
36 35, 42, 49, 56, 57, 50, 43, 36,
37 29, 22, 15, 23, 30, 37, 44, 51,
38 58, 59, 52, 45, 38, 31, 39, 46,
39 53, 60, 61, 54, 47, 55, 62, 63
42 const LEVEL_SCALE: [[i16; 6]; 3] = [
43 [ 10, 11, 13, 14, 16, 18 ],
44 [ 16, 18, 20, 23, 25, 29 ],
45 [ 13, 14, 16, 18, 20, 23 ]
48 pub fn chroma_dc_transform(blk: &mut [i16; 4], qp: u8) {
49 let t0 = blk[0] + blk[2];
50 let t1 = blk[0] - blk[2];
51 let t2 = blk[1] + blk[3];
52 let t3 = blk[1] - blk[3];
58 let mul = LEVEL_SCALE[0][qp as usize];
59 for el in blk.iter_mut() {
60 *el = el.wrapping_mul(mul) >> 1;
63 let mul = LEVEL_SCALE[0][(qp % 6) as usize];
64 let shift = qp / 6 - 1;
65 for el in blk.iter_mut() {
66 *el = el.wrapping_mul(mul) << shift;
71 macro_rules! transform {
72 (luma_dc; $a: expr, $b: expr, $c: expr, $d: expr) => ({
73 let t0 = $a.wrapping_add($c);
74 let t1 = $a.wrapping_sub($c);
75 let t2 = $b.wrapping_add($d);
76 let t3 = $b.wrapping_sub($d);
77 $a = t0.wrapping_add(t2);
78 $b = t1.wrapping_add(t3);
79 $c = t1.wrapping_sub(t3);
80 $d = t0.wrapping_sub(t2);
82 ($a: expr, $b: expr, $c: expr, $d: expr, $shift: expr) => ({
83 let t0 = $a.wrapping_add($c);
84 let t1 = $a.wrapping_sub($c);
85 let t2 = ($b >> 1).wrapping_sub($d);
86 let t3 = $b.wrapping_add($d >> 1);
87 let bias = 1 << $shift >> 1;
88 $a = t0.wrapping_add(t3).wrapping_add(bias) >> $shift;
89 $b = t1.wrapping_add(t2).wrapping_add(bias) >> $shift;
90 $c = t1.wrapping_sub(t2).wrapping_add(bias) >> $shift;
91 $d = t0.wrapping_sub(t3).wrapping_add(bias) >> $shift;
93 ($a: expr, $b: expr, $c: expr, $d: expr, $e: expr, $f: expr, $g: expr, $h: expr) => {
95 let e1 = -$d + $f - $h - ($h >> 1);
97 let e3 = $b + $h - $d - ($d >> 1);
98 let e4 = ($c >> 1) - $g;
99 let e5 = -$b + $h + $f + ($f >> 1);
100 let e6 = $c + ($g >> 1);
101 let e7 = $d + $f + $b + ($b >> 1);
104 let f1 = e1 + (e7 >> 2);
106 let f3 = e3 + (e5 >> 2);
108 let f5 = (e3 >> 2) - e5;
110 let f7 = e7 - (e1 >> 2);
123 pub fn idct_luma_dc(blk: &mut [i16; 16], qp: u8) {
125 let mul = LEVEL_SCALE[0][(qp % 6) as usize];
126 let shift = 2 - qp / 6;
127 let bias = 1 << shift >> 1;
128 for el in blk.iter_mut() {
129 *el = el.wrapping_mul(mul).wrapping_add(bias) >> shift;
132 let mul = LEVEL_SCALE[0][(qp % 6) as usize];
133 let shift = qp / 6 - 2;
134 for el in blk.iter_mut() {
135 *el = el.wrapping_mul(mul) << shift;
139 transform!(luma_dc; blk[i], blk[i + 4], blk[i + 8], blk[i + 12]);
141 for row in blk.chunks_mut(4) {
142 transform!(luma_dc; row[0], row[1], row[2], row[3]);
146 pub fn idct(blk: &mut [i16; 16], qp: u8, quant_dc: bool) {
147 const BLK_INDEX: [usize; 16] = [
153 let qidx = (qp % 6) as usize;
155 let start = if quant_dc { 0 } else { 1 };
156 for (el, &idx) in blk.iter_mut().zip(BLK_INDEX.iter()).skip(start) {
157 *el = (*el * LEVEL_SCALE[idx][qidx]) << shift;
159 for row in blk.chunks_mut(4) {
160 transform!(row[0], row[1], row[2], row[3], 0);
163 transform!(blk[i], blk[i + 4], blk[i + 8], blk[i + 12], 6);
167 pub fn idct_dc(blk: &mut [i16; 16], qp: u8, quant_dc: bool) {
168 let dc = if quant_dc {
169 (blk[0] * LEVEL_SCALE[0][(qp % 6) as usize]) << (qp / 6)
173 *blk = [(dc + 0x20) >> 6; 16];
176 const QMAT_8X8: [[u8; 16]; 6] = [
210 pub fn dequant8x8(blk: &mut [i16; 64], slist: &[u8; 64]) {
211 for (el, &scan) in blk.iter_mut().zip(ZIGZAG8X8.iter()) {
213 *el = el.wrapping_mul(i16::from(slist[scan]));
218 pub fn idct8x8(blk: &mut [i16; 64], qp: u8) {
219 let mut tmp = [0i32; 64];
220 let qmat = &QMAT_8X8[(qp % 6) as usize];
222 let shift = qp / 6 - 6;
223 for (i, (dst, &src)) in tmp.iter_mut().zip(blk.iter()).enumerate() {
226 let idx = (x & 3) + (y & 3) * 4;
227 *dst = i32::from(src).wrapping_mul(i32::from(qmat[idx])) << shift;
230 let shift = 6 - qp / 6;
231 let bias = (1 << shift) >> 1;
232 for (i, (dst, &src)) in tmp.iter_mut().zip(blk.iter()).enumerate() {
235 let idx = (x & 3) + (y & 3) * 4;
236 *dst = i32::from(src).wrapping_mul(i32::from(qmat[idx])).wrapping_add(bias) >> shift;
239 for row in tmp.chunks_mut(8) {
240 transform!(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7]);
243 transform!(tmp[col], tmp[col + 8], tmp[col + 8 * 2], tmp[col + 8 * 3],
244 tmp[col + 8 * 4], tmp[col + 8 * 5], tmp[col + 8 * 6], tmp[col + 8 * 7]);
246 for (dst, &src) in blk.iter_mut().zip(tmp.iter()) {
247 *dst = ((src + 0x20) >> 6) as i16;
251 pub fn add_coeffs(dst: &mut [u8], offset: usize, stride: usize, coeffs: &[i16]) {
252 let out = &mut dst[offset..][..stride * 3 + 4];
253 for (line, src) in out.chunks_mut(stride).take(4).zip(coeffs.chunks(4)) {
254 for (dst, src) in line.iter_mut().take(4).zip(src.iter()) {
255 *dst = (i32::from(*dst) + i32::from(*src)).max(0).min(255) as u8;
260 pub fn add_coeffs8(dst: &mut [u8], offset: usize, stride: usize, coeffs: &[i16; 64]) {
261 let out = &mut dst[offset..];
262 for (line, src) in out.chunks_mut(stride).take(8).zip(coeffs.chunks(8)) {
263 for (dst, src) in line.iter_mut().take(8).zip(src.iter()) {
264 *dst = (i32::from(*dst) + i32::from(*src)).max(0).min(255) as u8;
269 pub fn avg(dst: &mut [u8], dstride: usize,
270 src: &[u8], sstride: usize, bw: usize, bh: usize) {
271 for (dline, sline) in dst.chunks_mut(dstride).zip(src.chunks(sstride)).take(bh) {
272 for (dst, src) in dline.iter_mut().zip(sline.iter()).take(bw) {
273 *dst = ((u16::from(*dst) + u16::from(*src) + 1) >> 1) as u8;
278 fn clip8(val: i16) -> u8 { val.max(0).min(255) as u8 }
280 fn ipred_dc128(buf: &mut [u8], stride: usize, bsize: usize) {
281 for row in buf.chunks_mut(stride).take(bsize) {
282 for el in row[..bsize].iter_mut() {
287 fn ipred_ver(buf: &mut [u8], stride: usize, top: &[u8], bsize: usize) {
288 for row in buf.chunks_mut(stride).take(bsize) {
289 row[..bsize].copy_from_slice(&top[..bsize]);
292 fn ipred_hor(buf: &mut [u8], stride: usize, left: &[u8], bsize: usize) {
293 for (row, &left) in buf.chunks_mut(stride).zip(left[1..].iter()).take(bsize) {
294 for el in row[..bsize].iter_mut() {
299 fn ipred_dc(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8], bsize: usize, shift: u8) {
300 let mut adc: u16 = 0;
301 for i in 0..bsize { adc += u16::from(top[i]); }
302 for i in 0..bsize { adc += u16::from(left[i + 1]); }
303 let dc = ((adc + (1 << (shift - 1))) >> shift) as u8;
305 for row in buf.chunks_mut(stride).take(bsize) {
306 for el in row[..bsize].iter_mut() {
311 fn ipred_left_dc(buf: &mut [u8], stride: usize, left: &[u8], bsize: usize, shift: u8) {
312 let mut adc: u16 = 0;
313 for i in 0..bsize { adc += u16::from(left[i + 1]); }
314 let dc = ((adc + (1 << (shift - 1))) >> shift) as u8;
316 for row in buf.chunks_mut(stride).take(bsize) {
317 for el in row[..bsize].iter_mut() {
322 fn ipred_top_dc(buf: &mut [u8], stride: usize, top: &[u8], bsize: usize, shift: u8) {
323 let mut adc: u16 = 0;
324 for i in 0..bsize { adc += u16::from(top[i]); }
325 let dc = ((adc + (1 << (shift - 1))) >> shift) as u8;
327 for row in buf.chunks_mut(stride).take(bsize) {
328 for el in row[..bsize].iter_mut() {
334 fn load(dst: &mut [u16], src: &[u8]) {
335 for (dst, &src) in dst.iter_mut().zip(src.iter()) {
336 *dst = u16::from(src);
340 fn ipred_4x4_ver(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8], _tr: &[u8]) {
341 ipred_ver(buf, stride, top, 4);
343 fn ipred_4x4_hor(buf: &mut [u8], stride: usize, _top: &[u8], left: &[u8], _tr: &[u8]) {
344 ipred_hor(buf, stride, left, 4);
346 fn ipred_4x4_diag_down_left(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8], tr: &[u8]) {
347 let mut t: [u16; 9] = [0; 9];
348 load(&mut t[..4], top);
349 load(&mut t[4..8], tr);
353 buf[i] = ((t[i] + 2 * t[i + 1] + t[i + 2] + 2) >> 2) as u8;
355 let dst = &mut buf[stride..];
357 dst[i] = ((t[i + 1] + 2 * t[i + 2] + t[i + 3] + 2) >> 2) as u8;
359 let dst = &mut buf[stride * 2..];
361 dst[i] = ((t[i + 2] + 2 * t[i + 3] + t[i + 4] + 2) >> 2) as u8;
363 let dst = &mut buf[stride * 3..];
365 dst[i] = ((t[i + 3] + 2 * t[i + 4] + t[i + 5] + 2) >> 2) as u8;
368 fn ipred_4x4_diag_down_right(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8], _tr: &[u8]) {
369 let mut t: [u16; 5] = [0; 5];
370 t[0] = u16::from(left[0]);
371 load(&mut t[1..], &top);
372 let mut l: [u16; 5] = [0; 5];
378 dst[i + j * stride] = ((l[j - i - 1] + 2 * l[j - i] + l[j - i + 1] + 2) >> 2) as u8;
380 dst[j + j * stride] = ((l[1] + 2 * l[0] + t[1] + 2) >> 2) as u8;
382 dst[i + j * stride] = ((t[i - j - 1] + 2 * t[i - j] + t[i - j + 1] + 2) >> 2) as u8;
386 fn ipred_4x4_ver_right(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8], _tr: &[u8]) {
387 let mut t: [u16; 5] = [0; 5];
388 t[0] = u16::from(left[0]);
389 load(&mut t[1..], &top);
390 let mut l: [u16; 5] = [0; 5];
396 let zvr = ((2 * i) as i8) - (j as i8);
400 pix = (t[i - (j >> 1)] + t[i - (j >> 1) + 1] + 1) >> 1;
402 pix = (t[i - (j >> 1) - 1] + 2 * t[i - (j >> 1)] + t[i - (j >> 1) + 1] + 2) >> 2;
406 pix = (l[1] + 2 * l[0] + t[1] + 2) >> 2;
408 pix = (l[j] + 2 * l[j - 1] + l[j - 2] + 2) >> 2;
411 dst[i + j * stride] = pix as u8;
415 fn ipred_4x4_ver_left(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8], tr: &[u8]) {
416 let mut t: [u16; 8] = [0; 8];
417 load(&mut t[..4], &top);
418 load(&mut t[4..], tr);
421 dst[0 + 0 * stride] = ((t[0] + t[1] + 1) >> 1) as u8;
422 let pix = ((t[1] + t[2] + 1) >> 1) as u8;
423 dst[1 + 0 * stride] = pix;
424 dst[0 + 2 * stride] = pix;
425 let pix = ((t[2] + t[3] + 1) >> 1) as u8;
426 dst[2 + 0 * stride] = pix;
427 dst[1 + 2 * stride] = pix;
428 let pix = ((t[3] + t[4] + 1) >> 1) as u8;
429 dst[3 + 0 * stride] = pix;
430 dst[2 + 2 * stride] = pix;
431 dst[3 + 2 * stride] = ((t[4] + t[5] + 1) >> 1) as u8;
432 dst[0 + 1 * stride] = ((t[0] + 2*t[1] + t[2] + 2) >> 2) as u8;
433 let pix = ((t[1] + 2*t[2] + t[3] + 2) >> 2) as u8;
434 dst[1 + 1 * stride] = pix;
435 dst[0 + 3 * stride] = pix;
436 let pix = ((t[2] + 2*t[3] + t[4] + 2) >> 2) as u8;
437 dst[2 + 1 * stride] = pix;
438 dst[1 + 3 * stride] = pix;
439 let pix = ((t[3] + 2*t[4] + t[5] + 2) >> 2) as u8;
440 dst[3 + 1 * stride] = pix;
441 dst[2 + 3 * stride] = pix;
442 dst[3 + 3 * stride] = ((t[4] + 2*t[5] + t[6] + 2) >> 2) as u8;
444 fn ipred_4x4_hor_down(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8], _tr: &[u8]) {
445 let mut t: [u16; 5] = [0; 5];
446 t[0] = u16::from(left[0]);
447 load(&mut t[1..], &top);
448 let mut l: [u16; 5] = [0; 5];
454 let zhd = ((2 * j) as i8) - (i as i8);
458 pix = (l[j - (i >> 1)] + l[j - (i >> 1) + 1] + 1) >> 1;
460 pix = (l[j - (i >> 1) - 1] + 2 * l[j - (i >> 1)] + l[j - (i >> 1) + 1] + 2) >> 2;
464 pix = (l[1] + 2 * l[0] + t[1] + 2) >> 2;
466 pix = (t[i - 2] + 2 * t[i - 1] + t[i] + 2) >> 2;
469 dst[i + j * stride] = pix as u8;
473 fn ipred_4x4_hor_up(buf: &mut [u8], stride: usize, _top: &[u8], left: &[u8], _tr: &[u8]) {
474 let mut l: [u16; 8] = [0; 8];
475 load(&mut l, &left[1..]);
478 dst[0 + 0 * stride] = ((l[0] + l[1] + 1) >> 1) as u8;
479 dst[1 + 0 * stride] = ((l[0] + 2*l[1] + l[2] + 2) >> 2) as u8;
480 let pix = ((l[1] + l[2] + 1) >> 1) as u8;
481 dst[2 + 0 * stride] = pix;
482 dst[0 + 1 * stride] = pix;
483 let pix = ((l[1] + 2*l[2] + l[3] + 2) >> 2) as u8;
484 dst[3 + 0 * stride] = pix;
485 dst[1 + 1 * stride] = pix;
486 let pix = ((l[2] + l[3] + 1) >> 1) as u8;
487 dst[2 + 1 * stride] = pix;
488 dst[0 + 2 * stride] = pix;
489 let pix = ((l[2] + 3*l[3] + 2) >> 2) as u8;
490 dst[3 + 1 * stride] = pix;
491 dst[1 + 2 * stride] = pix;
492 dst[3 + 2 * stride] = l[3] as u8;
493 dst[1 + 3 * stride] = l[3] as u8;
494 dst[0 + 3 * stride] = l[3] as u8;
495 dst[2 + 2 * stride] = l[3] as u8;
496 dst[2 + 3 * stride] = l[3] as u8;
497 dst[3 + 3 * stride] = l[3] as u8;
499 fn ipred_4x4_dc(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8], _tr: &[u8]) {
500 ipred_dc(buf, stride, top, left, 4, 3);
502 fn ipred_4x4_left_dc(buf: &mut [u8], stride: usize, _top: &[u8], left: &[u8], _tr: &[u8]) {
503 ipred_left_dc(buf, stride, left, 4, 2);
505 fn ipred_4x4_top_dc(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8], _tr: &[u8]) {
506 ipred_top_dc(buf, stride, top, 4, 2);
508 fn ipred_4x4_dc128(buf: &mut [u8], stride: usize, _top: &[u8], _left: &[u8], _tr: &[u8]) {
509 ipred_dc128(buf, stride, 4);
512 pub struct IPred8Context {
519 pub fn new() -> Self {
526 pub fn fill(&mut self, top: &[u8], left: &[u8], has_t: bool, has_tr: bool, has_l: bool, has_tl: bool) {
527 let mut t = [0x80u8; 19];
528 let mut l = [0x80u8; 11];
530 t[1..8 + 1].copy_from_slice(&top[..8]);
533 t[8 + 1..16 + 1].copy_from_slice(&top[8..][..8]);
534 t[16 + 1] = t[15 + 1];
535 t[17 + 1] = t[15 + 1];
537 let (t0, t1) = t.split_at_mut(8 + 1);
538 for el in t1.iter_mut() {
543 l[1..9].copy_from_slice(&left[1..9]);
556 self.t[i] = ((u16::from(t[i]) + 2 * u16::from(t[i + 1]) + u16::from(t[i + 2]) + 2) >> 2) as u8;
559 self.l[i] = ((u16::from(l[i]) + 2 * u16::from(l[i + 1]) + u16::from(l[i + 2]) + 2) >> 2) as u8;
561 self.tl = if has_t && has_l {
562 ((u16::from(t[1]) + 2 * u16::from(t[0]) + u16::from(l[1]) + 2) >> 2) as u8
564 ((3 * u16::from(t[0]) + u16::from(t[1]) + 2) >> 2) as u8
566 ((3 * u16::from(l[0]) + u16::from(l[1]) + 2) >> 2) as u8
573 fn ipred_y_8x8_ver(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
574 for row in buf.chunks_mut(stride).take(8) {
575 row[..8].copy_from_slice(&ctx.t[..8]);
578 fn ipred_y_8x8_hor(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
579 for (row, &l) in buf.chunks_mut(stride).zip(ctx.l.iter()).take(8) {
580 row[..8].copy_from_slice(&[l; 8]);
583 fn ipred_y_8x8_diag_down_left(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
584 let mut t = [0u16; 16];
585 load(&mut t, &ctx.t);
587 for (y, row) in buf.chunks_mut(stride).take(8).enumerate() {
588 for (x, pix) in row.iter_mut().take(8).enumerate() {
589 *pix = ((if (x != 7) || (y != 7) {
590 t[x + y] + 2 * t[x + y + 1] + t[x + y + 2]
597 fn ipred_y_8x8_diag_down_right(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
598 let mut t = [0u16; 9];
599 t[0] = u16::from(ctx.tl);
600 load(&mut t[1..], &ctx.t);
601 let mut l = [0u16; 9];
602 l[0] = u16::from(ctx.tl);
603 load(&mut l[1..], &ctx.l);
604 let diag = t[1] + 2 * t[0] + l[1];
606 for (y, row) in buf.chunks_mut(stride).take(8).enumerate() {
607 for (x, pix) in row.iter_mut().take(8).enumerate() {
609 t[x - y - 1] + 2 * t[x - y] + t[x - y + 1]
611 l[y - x - 1] + 2 * l[y - x] + l[y - x + 1]
618 fn ipred_y_8x8_ver_right(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
619 let mut t = [0u16; 9];
620 t[0] = u16::from(ctx.tl);
621 load(&mut t[1..], &ctx.t);
622 let mut l = [0u16; 9];
623 l[0] = u16::from(ctx.tl);
624 load(&mut l[1..], &ctx.l);
626 for (y, row) in buf.chunks_mut(stride).take(8).enumerate() {
627 for (x, pix) in row.iter_mut().take(8).enumerate() {
628 let zvr = 2 * (x as i8) - (y as i8);
630 let ix = x - (y >> 1);
632 (t[ix] + t[ix + 1] + 1) >> 1
634 (t[ix - 1] + 2 * t[ix] + t[ix + 1] + 2) >> 2
636 } else if zvr == -1 {
637 (l[1] + 2 * l[0] + t[1] + 2) >> 2
640 (l[ix] + 2 * l[ix - 1] + l[ix - 2] + 2) >> 2
645 fn ipred_y_8x8_ver_left(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
646 let mut t = [0u16; 16];
647 load(&mut t, &ctx.t);
649 for (y, row) in buf.chunks_mut(stride).take(8).enumerate() {
650 for (x, pix) in row.iter_mut().take(8).enumerate() {
651 let ix = x + (y >> 1);
652 *pix = if (y & 1) == 0 {
653 (t[ix] + t[ix + 1] + 1) >> 1
655 (t[ix] + 2 * t[ix + 1] + t[ix + 2] + 2) >> 2
661 fn ipred_y_8x8_hor_down(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
662 let mut t = [0u16; 9];
663 t[0] = u16::from(ctx.tl);
664 load(&mut t[1..], &ctx.t);
665 let mut l = [0u16; 9];
666 l[0] = u16::from(ctx.tl);
667 load(&mut l[1..], &ctx.l);
669 for (y, row) in buf.chunks_mut(stride).take(8).enumerate() {
670 for (x, pix) in row.iter_mut().take(8).enumerate() {
671 let zhd = 2 * (y as i8) - (x as i8);
673 let ix = y - (x >> 1);
675 (l[ix] + l[ix + 1] + 1) >> 1
677 (l[ix - 1] + 2 * l[ix] + l[ix + 1] + 2) >> 2
679 } else if zhd == -1 {
680 (l[1] + 2 * l[0] + t[1] + 2) >> 2
683 (t[ix] + 2 * t[ix - 1] + t[ix - 2] + 2) >> 2
688 fn ipred_y_8x8_hor_up(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
689 let mut l = [0u16; 8];
690 load(&mut l, &ctx.l);
692 for (y, row) in buf.chunks_mut(stride).take(8).enumerate() {
693 for (x, pix) in row.iter_mut().take(8).enumerate() {
695 let ix = y + (x >> 1);
698 } else if zhu == 13 {
699 (l[6] + 3 * l[7] + 2) >> 2
700 } else if (zhu & 1) != 0 {
701 (l[ix] + 2 * l[ix + 1] + l[ix + 2] + 2) >> 2
703 (l[ix] + l[ix + 1] + 1) >> 1
708 fn ipred_y_8x8_dc(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
710 for &t in ctx.t[..8].iter() {
713 for &l in ctx.l[..8].iter() {
716 let dc = ((sum + 8) >> 4) as u8;
717 for row in buf.chunks_mut(stride).take(8) {
718 for pix in row.iter_mut().take(8) {
723 fn ipred_y_8x8_left_dc(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
725 for &l in ctx.l[..8].iter() {
728 let dc = ((sum + 4) >> 3) as u8;
729 for row in buf.chunks_mut(stride).take(8) {
730 for pix in row.iter_mut().take(8) {
735 fn ipred_y_8x8_top_dc(buf: &mut [u8], stride: usize, ctx: &IPred8Context) {
737 for &t in ctx.t[..8].iter() {
740 let dc = ((sum + 4) >> 3) as u8;
741 for row in buf.chunks_mut(stride).take(8) {
742 for pix in row.iter_mut().take(8) {
747 fn ipred_y_8x8_dc128(buf: &mut [u8], stride: usize, _ctx: &IPred8Context) {
748 ipred_dc128(buf, stride, 8);
751 fn ipred_8x8_ver(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8]) {
752 ipred_ver(buf, stride, top, 8);
754 fn ipred_8x8_hor(buf: &mut [u8], stride: usize, _top: &[u8], left: &[u8]) {
755 ipred_hor(buf, stride, left, 8);
757 fn ipred_8x8_dc(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8]) {
759 load(&mut l, &left[1..]);
763 let dc0 = ((t[0] + t[1] + t[2] + t[3] + l[0] + l[1] + l[2] + l[3] + 4) >> 3) as u8;
764 let sum1 = t[4] + t[5] + t[6] + t[7];
765 let dc1 = ((sum1 + 2) >> 2) as u8;
766 let sum2 = l[4] + l[5] + l[6] + l[7];
767 let dc2 = ((sum2 + 2) >> 2) as u8;
768 let dc3 = ((sum1 + sum2 + 4) >> 3) as u8;
770 for row in buf.chunks_mut(stride).take(4) {
771 row[..4].copy_from_slice(&[dc0; 4]);
772 row[4..8].copy_from_slice(&[dc1; 4]);
774 for row in buf.chunks_mut(stride).skip(4).take(4) {
775 row[..4].copy_from_slice(&[dc2; 4]);
776 row[4..8].copy_from_slice(&[dc3; 4]);
779 fn ipred_8x8_left_dc(buf: &mut [u8], stride: usize, _top: &[u8], left: &[u8]) {
780 let mut left_dc0 = 0;
781 let mut left_dc1 = 0;
782 for &el in left[1..].iter().take(4) {
783 left_dc0 += u16::from(el);
785 for &el in left[1..].iter().skip(4).take(4) {
786 left_dc1 += u16::from(el);
788 let dc0 = ((left_dc0 + 2) >> 2) as u8;
789 let dc2 = ((left_dc1 + 2) >> 2) as u8;
790 for row in buf.chunks_mut(stride).take(4) {
791 row[..8].copy_from_slice(&[dc0; 8]);
793 for row in buf.chunks_mut(stride).skip(4).take(4) {
794 row[..8].copy_from_slice(&[dc2; 8]);
797 fn ipred_8x8_top_dc(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8]) {
798 ipred_top_dc(buf, stride, top, 4, 2);
799 ipred_top_dc(&mut buf[4..], stride, &top[4..], 4, 2);
800 let mut top = [0; 8];
801 top.copy_from_slice(&buf[stride * 3..][..8]);
802 ipred_top_dc(&mut buf[4 * stride..], stride, &top, 4, 2);
803 ipred_top_dc(&mut buf[4 + 4 * stride..], stride, &top[4..], 4, 2);
805 fn ipred_8x8_dc128(buf: &mut [u8], stride: usize, _top: &[u8], _left: &[u8]) {
806 ipred_dc128(buf, stride, 8);
808 fn ipred_8x8_plane(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8]) {
809 let mut h: i32 = 4 * (i32::from(top[7]) - i32::from(left[0]));
810 let mut v: i32 = 4 * (i32::from(left[8]) - i32::from(left[0]));
812 let i1 = (i + 1) as i32;
813 h += i1 * (i32::from(top[4 + i]) - i32::from(top[2 - i]));
814 v += i1 * (i32::from(left[5 + i]) - i32::from(left[3 - i]));
816 let b = (17 * h + 16) >> 5;
817 let c = (17 * v + 16) >> 5;
818 let mut a = 16 * (i32::from(left[8]) + i32::from(top[7])) - 3 * (b + c) + 16;
819 for line in buf.chunks_mut(stride).take(8) {
821 for el in line.iter_mut().take(8) {
822 *el = clip8((acc >> 5) as i16);
829 fn ipred_16x16_ver(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8]) {
830 ipred_ver(buf, stride, top, 16);
832 fn ipred_16x16_hor(buf: &mut [u8], stride: usize, _top: &[u8], left: &[u8]) {
833 ipred_hor(buf, stride, left, 16);
835 fn ipred_16x16_dc(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8]) {
836 ipred_dc(buf, stride, top, left, 16, 5);
838 fn ipred_16x16_left_dc(buf: &mut [u8], stride: usize, _top: &[u8], left: &[u8]) {
839 ipred_left_dc(buf, stride, left, 16, 4);
841 fn ipred_16x16_top_dc(buf: &mut [u8], stride: usize, top: &[u8], _left: &[u8]) {
842 ipred_top_dc(buf, stride, top, 16, 4);
844 fn ipred_16x16_dc128(buf: &mut [u8], stride: usize, _top: &[u8], _left: &[u8]) {
845 ipred_dc128(buf, stride, 16);
847 fn ipred_16x16_plane(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8]) {
848 let mut h = 8 * (i32::from(top[15]) - i32::from(left[0]));
849 let mut v = 8 * (i32::from(left[16]) - i32::from(left[0]));
851 h += ((k as i32) + 1) * (i32::from(top[8 + k]) - i32::from(top[6 - k]));
852 v += ((k as i32) + 1) * (i32::from(left[9 + k]) - i32::from(left[7 - k]));
855 h = (5 * h + 32) >> 6;
856 v = (5 * v + 32) >> 6;
858 let mut a = 16 * (i32::from(left[16]) + i32::from(top[15]) + 1) - 7 * (v + h);
860 for row in buf.chunks_mut(stride).take(16) {
864 for dst in row.chunks_exact_mut(4).take(4) {
865 dst[0] = clip8(((b ) >> 5) as i16);
866 dst[1] = clip8(((b + h) >> 5) as i16);
867 dst[2] = clip8(((b + 2*h) >> 5) as i16);
868 dst[3] = clip8(((b + 3*h) >> 5) as i16);
874 pub type IPred4x4Func = fn(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8], tr: &[u8]);
875 pub type IPred8x8Func = fn(buf: &mut [u8], stride: usize, top: &[u8], left: &[u8]);
876 pub type IPred8x8LumaFunc = fn(buf: &mut [u8], stride: usize, ctx: &IPred8Context);
878 pub const IPRED4_DC128: usize = 11;
879 pub const IPRED4_DC_TOP: usize = 10;
880 pub const IPRED4_DC_LEFT: usize = 9;
881 pub const IPRED8_DC128: usize = 6;
882 pub const IPRED8_DC_TOP: usize = 5;
883 pub const IPRED8_DC_LEFT: usize = 4;
885 pub const IPRED_FUNCS4X4: [IPred4x4Func; 12] = [
886 ipred_4x4_ver, ipred_4x4_hor, ipred_4x4_dc,
887 ipred_4x4_diag_down_left, ipred_4x4_diag_down_right,
888 ipred_4x4_ver_right, ipred_4x4_hor_down, ipred_4x4_ver_left, ipred_4x4_hor_up,
889 ipred_4x4_left_dc, ipred_4x4_top_dc, ipred_4x4_dc128
892 pub const IPRED_FUNCS8X8_LUMA: [IPred8x8LumaFunc; 12] = [
893 ipred_y_8x8_ver, ipred_y_8x8_hor, ipred_y_8x8_dc,
894 ipred_y_8x8_diag_down_left, ipred_y_8x8_diag_down_right,
895 ipred_y_8x8_ver_right, ipred_y_8x8_hor_down,
896 ipred_y_8x8_ver_left, ipred_y_8x8_hor_up,
897 ipred_y_8x8_left_dc, ipred_y_8x8_top_dc, ipred_y_8x8_dc128
900 pub const IPRED_FUNCS8X8_CHROMA: [IPred8x8Func; 7] = [
901 ipred_8x8_dc, ipred_8x8_hor, ipred_8x8_ver, ipred_8x8_plane,
902 ipred_8x8_left_dc, ipred_8x8_top_dc, ipred_8x8_dc128
905 pub const IPRED_FUNCS16X16: [IPred8x8Func; 7] = [
906 ipred_16x16_ver, ipred_16x16_hor, ipred_16x16_dc, ipred_16x16_plane,
907 ipred_16x16_left_dc, ipred_16x16_top_dc, ipred_16x16_dc128
910 fn clip_u8(val: i16) -> u8 { val.max(0).min(255) as u8 }
912 pub fn do_mc(frm: &mut NASimpleVideoFrame<u8>, refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
913 let mode = ((mv.x & 3) + (mv.y & 3) * 4) as usize;
914 copy_block(frm, refpic.clone(), 0, xpos, ypos, mv.x >> 2, mv.y >> 2, w, h, 2, 3, mode, H264_LUMA_INTERP);
916 let (cw, ch) = refpic.get_dimensions(1);
919 let dx = (mv.x & 7) as u16;
920 let dy = (mv.y & 7) as u16;
921 let mut ebuf = [0u8; 18 * 9];
922 let src_x = ((xpos >> 1) as isize) + (mvx as isize);
923 let src_y = ((ypos >> 1) as isize) + (mvy as isize);
924 let suoff = refpic.get_offset(1);
925 let svoff = refpic.get_offset(2);
926 let sustride = refpic.get_stride(1);
927 let svstride = refpic.get_stride(2);
928 let src = refpic.get_data();
931 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)) {
932 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf, 18, 1, 4);
933 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf[9..], 18, 2, 4);
934 ([&ebuf, &ebuf[9..]], [18, 18])
936 ([&src[suoff + (src_x as usize) + (src_y as usize) * sustride..],
937 &src[svoff + (src_x as usize) + (src_y as usize) * svstride..]],
938 [sustride, svstride])
941 let off = frm.offset[chroma] + xpos / 2 + (ypos / 2) * frm.stride[chroma];
942 chroma_interp(&mut frm.data[off..], frm.stride[chroma], csrc[chroma - 1], cstride[chroma - 1], dx, dy, cbw, cbh);
946 pub fn mc_blocks(ydst: &mut [u8], udst: &mut [u8], vdst: &mut [u8], refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
947 let mode = ((mv.x & 3) + (mv.y & 3) * 4) as usize;
949 let pre = if mode != 0 { 2 } else { 0 };
950 let post = if mode != 0 { 3 } else { 0 };
951 let (width, height) = refpic.get_dimensions(0);
952 let sx = (xpos as isize) + ((mv.x >> 2) as isize);
953 let sy = (ypos as isize) + ((mv.y >> 2) as isize);
955 const EBUF_STRIDE: usize = 32;
956 let mut ebuf = [0u8; EBUF_STRIDE * (16 + 2 + 3)];
958 if (sx - pre < 0) || (sx + (w as isize) + post > (width as isize)) ||
959 (sy - pre < 0) || (sy + (h as isize) + post > (height as isize)) {
960 let edge = (pre + post) as usize;
961 edge_emu(&refpic, sx - pre, sy - pre, w + edge, h + edge,
962 &mut ebuf, EBUF_STRIDE, 0, 0);
963 (H264_LUMA_INTERP[mode])(ydst, 16, &ebuf, EBUF_STRIDE, w, h);
965 let sstride = refpic.get_stride(0);
966 let soff = refpic.get_offset(0);
967 let sdta = refpic.get_data();
968 let sbuf: &[u8] = sdta.as_slice();
969 let saddr = soff + ((sx - pre) as usize) + ((sy - pre) as usize) * sstride;
970 (H264_LUMA_INTERP[mode])(ydst, 16, &sbuf[saddr..], sstride, w, h);
973 let (cw, ch) = refpic.get_dimensions(1);
976 let dx = (mv.x & 7) as u16;
977 let dy = (mv.y & 7) as u16;
978 let src_x = ((xpos >> 1) as isize) + (mvx as isize);
979 let src_y = ((ypos >> 1) as isize) + (mvy as isize);
980 let suoff = refpic.get_offset(1);
981 let svoff = refpic.get_offset(2);
982 let sustride = refpic.get_stride(1);
983 let svstride = refpic.get_stride(2);
984 let src = refpic.get_data();
987 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)) {
988 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf, 18, 1, 4);
989 edge_emu(&refpic, src_x, src_y, cbw+1, cbh+1, &mut ebuf[9..], 18, 2, 4);
990 ([&ebuf, &ebuf[9..]], [18, 18])
992 ([&src[suoff + (src_x as usize) + (src_y as usize) * sustride..],
993 &src[svoff + (src_x as usize) + (src_y as usize) * svstride..]],
994 [sustride, svstride])
996 chroma_interp(udst, 16, csrc[0], cstride[0], dx, dy, cbw, cbh);
997 chroma_interp(vdst, 16, csrc[1], cstride[1], dx, dy, cbw, cbh);
1000 pub fn gray_block(frm: &mut NASimpleVideoFrame<u8>, x: usize, y: usize, w: usize, h: usize) {
1001 let yoff = frm.offset[0] + x + y * frm.stride[0];
1002 let coff = [frm.offset[1] + x / 2 + y / 2 * frm.stride[1],
1003 frm.offset[2] + x / 2 + y / 2 * frm.stride[2]];
1004 if w == 16 && h == 16 {
1005 IPRED_FUNCS16X16[IPRED8_DC128](&mut frm.data[yoff..], frm.stride[0], &[], &[]);
1006 for chroma in 1..2 {
1007 IPRED_FUNCS8X8_CHROMA[IPRED8_DC128](&mut frm.data[coff[chroma - 1]..], frm.stride[chroma], &[], &[]);
1009 } else if w == 8 && h == 8 {
1010 IPRED_FUNCS8X8_CHROMA[IPRED8_DC128](&mut frm.data[yoff..], frm.stride[0], &[], &[]);
1011 for chroma in 1..2 {
1012 IPRED_FUNCS4X4[IPRED4_DC128](&mut frm.data[coff[chroma - 1]..], frm.stride[chroma], &[128; 4], &[128; 4], &[128; 4]);
1015 for row in frm.data[yoff..].chunks_mut(frm.stride[0]).take(h) {
1016 for el in row[..w].iter_mut() {
1020 for chroma in 0..2 {
1021 for row in frm.data[coff[chroma]..].chunks_mut(frm.stride[chroma + 1]).take(h / 2) {
1022 for el in row[..w / 2].iter_mut() {
1030 pub fn do_mc_avg(frm: &mut NASimpleVideoFrame<u8>, refpic: NAVideoBufferRef<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV, avg_buf: &mut NAVideoBufferRef<u8>) {
1031 let mut afrm = NASimpleVideoFrame::from_video_buf(avg_buf).unwrap();
1032 let amv = MV { x: mv.x + (xpos as i16) * 4, y: mv.y + (ypos as i16) * 4 };
1033 do_mc(&mut afrm, refpic, 0, 0, w, h, amv);
1035 let shift = if comp == 0 { 0 } else { 1 };
1036 avg(&mut frm.data[frm.offset[comp] + (xpos >> shift) + (ypos >> shift) * frm.stride[comp]..], frm.stride[comp], &afrm.data[afrm.offset[comp]..], afrm.stride[comp], w >> shift, h >> shift);
1040 pub fn put_block_weighted(dst: &mut [u8], stride: usize, src: &[u8], w: usize, h: usize, wparams: [i8; 3]) {
1041 let weight = i16::from(wparams[0]);
1042 let offset = i16::from(wparams[1]);
1043 let wshift = wparams[2] as u8;
1044 let bias = (1 << wshift) >> 1;
1046 for (drow, srow) in dst.chunks_mut(stride).zip(src.chunks(16)).take(h) {
1047 for (dst, &src) in drow[..w].iter_mut().zip(srow.iter()) {
1048 *dst = clip8(((i16::from(src) * weight + bias) >> wshift) + offset);
1053 pub fn put_block_weighted2(dst: &mut [u8], stride: usize, src0: &[u8], src1: &[u8], w: usize, h: usize, wparams: [i8; 5]) {
1054 let weight0 = i16::from(wparams[0]);
1055 let offset0 = i16::from(wparams[1]);
1056 let weight1 = i16::from(wparams[2]);
1057 let offset1 = i16::from(wparams[3]);
1058 let wshift = (wparams[4] as u8) + 1;
1059 let offset = (offset0 + offset1 + 1) >> 1;
1060 let bias = (1 << wshift) >> 1;
1062 for (drow, (srow0, srow1)) in dst.chunks_mut(stride).zip(src0.chunks(16).zip(src1.chunks(16))).take(h) {
1063 for (dst, (&src0, &src1)) in drow[..w].iter_mut().zip(srow0.iter().zip(srow1.iter())) {
1064 *dst = clip8(((i16::from(src0) * weight0 + i16::from(src1) * weight1 + bias) >> wshift) + offset);
1069 macro_rules! loop_filter {
1070 (lumaedge; $buf: expr, $off: expr, $step: expr, $alpha: expr, $beta: expr) => {
1071 let p2 = i16::from($buf[$off - $step * 3]);
1072 let p1 = i16::from($buf[$off - $step * 2]);
1073 let p0 = i16::from($buf[$off - $step]);
1074 let q0 = i16::from($buf[$off]);
1075 let q1 = i16::from($buf[$off + $step]);
1076 let q2 = i16::from($buf[$off + $step * 2]);
1077 let a_p = (p2 - p0).abs() < $beta;
1078 let a_q = (q2 - q0).abs() < $beta;
1079 if a_p && (p0 - q0).abs() < (($alpha >> 2) + 2) {
1080 let p3 = i16::from($buf[$off - $step * 4]);
1081 $buf[$off - $step * 3] = ((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3) as u8;
1082 $buf[$off - $step * 2] = ((p2 + p1 + p0 + q0 + 2) >> 2) as u8;
1083 $buf[$off - $step] = ((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3) as u8;
1085 $buf[$off - $step] = ((2 * p1 + p0 + q1 + 2) >> 2) as u8;
1087 if a_q && (p0 - q0).abs() < (($alpha >> 2) + 2) {
1088 let q3 = i16::from($buf[$off + $step * 3]);
1089 $buf[$off] = ((p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3) as u8;
1090 $buf[$off + $step] = ((p0 + q0 + q1 + q2 + 2) >> 2) as u8;
1091 $buf[$off + $step * 2] = ((2 * q3 + 3 * q2 + q1 + q0 + p0 + 4) >> 3) as u8;
1093 $buf[$off] = ((2 * q1 + q0 + p1 + 2) >> 2) as u8;
1096 (chromaedge; $buf: expr, $off: expr, $step: expr) => {
1097 let p1 = i16::from($buf[$off - $step * 2]);
1098 let p0 = i16::from($buf[$off - $step]);
1099 let q0 = i16::from($buf[$off]);
1100 let q1 = i16::from($buf[$off + $step]);
1101 $buf[$off - $step] = ((2 * p1 + p0 + q1 + 2) >> 2) as u8;
1102 $buf[$off] = ((2 * q1 + q0 + p1 + 2) >> 2) as u8;
1104 (lumanormal; $buf: expr, $off: expr, $step: expr, $tc0: expr, $beta: expr) => {
1105 let p2 = i16::from($buf[$off - $step * 3]);
1106 let p1 = i16::from($buf[$off - $step * 2]);
1107 let p0 = i16::from($buf[$off - $step]);
1108 let q0 = i16::from($buf[$off]);
1109 let q1 = i16::from($buf[$off + $step]);
1110 let q2 = i16::from($buf[$off + $step * 2]);
1111 let a_p = (p2 - p0).abs() < $beta;
1112 let a_q = (q2 - q0).abs() < $beta;
1113 let tc = $tc0 + (a_p as i16) + (a_q as i16);
1114 let delta = (((q0 - p0) * 4 + (p1 - q1) + 4) >> 3).max(-tc).min(tc);
1115 if a_p && ($tc0 > 0) {
1116 $buf[$off - $step * 2] = clip8(p1 + ((p2 + ((p0 + q0 + 1) >> 1) - p1 * 2) >> 1).max(-$tc0).min($tc0));
1118 $buf[$off - $step] = clip8(p0 + delta);
1119 $buf[$off] = clip8(q0 - delta);
1120 if a_q && ($tc0 > 0) {
1121 $buf[$off + $step] = clip8(q1 + ((q2 + ((p0 + q0 + 1) >> 1) - q1 * 2) >> 1).max(-$tc0).min($tc0));
1124 (chromanormal; $buf: expr, $off: expr, $step: expr, $tc0: expr) => {
1125 let p1 = i16::from($buf[$off - $step * 2]);
1126 let p0 = i16::from($buf[$off - $step]);
1127 let q0 = i16::from($buf[$off]);
1128 let q1 = i16::from($buf[$off + $step]);
1130 let delta = (((q0 - p0) * 4 + (p1 - q1) + 4) >> 3).max(-tc).min(tc);
1131 $buf[$off - $step] = clip8(p0 + delta);
1132 $buf[$off] = clip8(q0 - delta);
1136 fn check_filter(buf: &[u8], off: usize, step: usize, alpha: i16, beta: i16) -> bool {
1137 let p1 = i16::from(buf[off - step * 2]);
1138 let p0 = i16::from(buf[off - step]);
1139 let q0 = i16::from(buf[off]);
1140 let q1 = i16::from(buf[off + step]);
1141 (p0 - q0).abs() < alpha && (p1 - p0).abs() < beta && (q1 - q0).abs() < beta
1144 pub fn loop_filter_lumaedge_v(dst: &mut [u8], mut off: usize, stride: usize, alpha: i16, beta: i16) {
1146 if check_filter(dst, off, 1, alpha, beta) {
1147 loop_filter!(lumaedge; dst, off, 1, alpha, beta);
1152 pub fn loop_filter_lumaedge_h(dst: &mut [u8], off: usize, stride: usize, alpha: i16, beta: i16) {
1154 if check_filter(dst, off + x, stride, alpha, beta) {
1155 loop_filter!(lumaedge; dst, off + x, stride, alpha, beta);
1159 pub fn loop_filter_lumanormal_v(dst: &mut [u8], mut off: usize, stride: usize, alpha: i16, beta: i16, tc0: i16) {
1161 if check_filter(dst, off, 1, alpha, beta) {
1162 loop_filter!(lumanormal; dst, off, 1, tc0, beta);
1167 pub fn loop_filter_lumanormal_h(dst: &mut [u8], off: usize, stride: usize, alpha: i16, beta: i16, tc0: i16) {
1169 if check_filter(dst, off + x, stride, alpha, beta) {
1170 loop_filter!(lumanormal; dst, off + x, stride, tc0, beta);
1174 pub fn loop_filter_chromaedge_v(dst: &mut [u8], mut off: usize, stride: usize, alpha: i16, beta: i16) {
1176 if check_filter(dst, off, 1, alpha, beta) {
1177 loop_filter!(chromaedge; dst, off, 1);
1182 pub fn loop_filter_chromaedge_h(dst: &mut [u8], off: usize, stride: usize, alpha: i16, beta: i16) {
1184 if check_filter(dst, off + x, stride, alpha, beta) {
1185 loop_filter!(chromaedge; dst, off + x, stride);
1189 pub fn loop_filter_chromanormal_v(dst: &mut [u8], mut off: usize, stride: usize, alpha: i16, beta: i16, tc0: i16) {
1191 if check_filter(dst, off, 1, alpha, beta) {
1192 loop_filter!(chromanormal; dst, off, 1, tc0);
1197 pub fn loop_filter_chromanormal_h(dst: &mut [u8], off: usize, stride: usize, alpha: i16, beta: i16, tc0: i16) {
1199 if check_filter(dst, off + x, stride, alpha, beta) {
1200 loop_filter!(chromanormal; dst, off + x, stride, tc0);