nihav-core/src/codecs/h263/code.rs

   1 use crate::frame::NAVideoBuffer;
   2 use super::{BlockDSP, CBPInfo, MV};
   3 use super::super::blockdsp;
   4 //use super::h263data::*;
   5
   6 /*const W1: i32 = 22725;
   7 const W2: i32 = 21407;
   8 const W3: i32 = 19266;
   9 const W4: i32 = 16383;
  10 const W5: i32 = 12873;
  11 const W6: i32 =  8867;
  12 const W7: i32 =  4520;
  13
  14 const ROW_SHIFT: u8 = 11;
  15 const COL_SHIFT: u8 = 20;
  16
  17 fn idct_row(row: &mut [i16]) {
  18     let in0 = row[0] as i32;
  19     let in1 = row[1] as i32;
  20     let in2 = row[2] as i32;
  21     let in3 = row[3] as i32;
  22     let in4 = row[4] as i32;
  23     let in5 = row[5] as i32;
  24     let in6 = row[6] as i32;
  25     let in7 = row[7] as i32;
  26
  27     let mut a0 = in0 * W1 + (1 << (ROW_SHIFT - 1));
  28     let mut a1 = a0;
  29     let mut a2 = a0;
  30     let mut a3 = a0;
  31
  32     a0 += W2 * in2;
  33     a1 += W6 * in2;
  34     a2 -= W6 * in2;
  35     a3 -= W2 * in2;
  36
  37     let mut b0 = W1 * in1 + W3 * in3;
  38     let mut b1 = W3 * in1 - W7 * in3;
  39     let mut b2 = W5 * in1 - W1 * in3;
  40     let mut b3 = W7 * in1 - W5 * in3;
  41
  42     a0 += W4 * in4 + W6 * in6;
  43     a1 -= W4 * in4 + W2 * in6;
  44     a2 -= W4 * in4 - W2 * in6;
  45     a3 += W4 * in4 - W6 * in6;
  46
  47     b0 += W5 * in5 + W7 * in7;
  48     b1 -= W1 * in5 + W5 * in7;
  49     b2 += W7 * in5 + W3 * in7;
  50     b3 += W3 * in5 - W1 * in7;
  51
  52     row[0] = ((a0 + b0) >> ROW_SHIFT) as i16;
  53     row[7] = ((a0 - b0) >> ROW_SHIFT) as i16;
  54     row[1] = ((a1 + b1) >> ROW_SHIFT) as i16;
  55     row[6] = ((a1 - b1) >> ROW_SHIFT) as i16;
  56     row[2] = ((a2 + b2) >> ROW_SHIFT) as i16;
  57     row[5] = ((a2 - b2) >> ROW_SHIFT) as i16;
  58     row[3] = ((a3 + b3) >> ROW_SHIFT) as i16;
  59     row[4] = ((a3 - b3) >> ROW_SHIFT) as i16;
  60 }
  61
  62 fn idct_col(blk: &mut [i16; 64], off: usize) {
  63     let in0 = blk[off + 0*8] as i32;
  64     let in1 = blk[off + 1*8] as i32;
  65     let in2 = blk[off + 2*8] as i32;
  66     let in3 = blk[off + 3*8] as i32;
  67     let in4 = blk[off + 4*8] as i32;
  68     let in5 = blk[off + 5*8] as i32;
  69     let in6 = blk[off + 6*8] as i32;
  70     let in7 = blk[off + 7*8] as i32;
  71
  72     let mut a0 = in0 * W1 + (1 << (COL_SHIFT - 1));
  73     let mut a1 = a0;
  74     let mut a2 = a0;
  75     let mut a3 = a0;
  76
  77     a0 += W2 * in2;
  78     a1 += W6 * in2;
  79     a2 -= W6 * in2;
  80     a3 -= W2 * in2;
  81
  82     let mut b0 = W1 * in1 + W3 * in3;
  83     let mut b1 = W3 * in1 - W7 * in3;
  84     let mut b2 = W5 * in1 - W1 * in3;
  85     let mut b3 = W7 * in1 - W5 * in3;
  86
  87     a0 += W4 * in4 + W6 * in6;
  88     a1 -= W4 * in4 + W2 * in6;
  89     a2 -= W4 * in4 - W2 * in6;
  90     a3 += W4 * in4 - W6 * in6;
  91
  92     b0 += W5 * in5 + W7 * in7;
  93     b1 -= W1 * in5 + W5 * in7;
  94     b2 += W7 * in5 + W3 * in7;
  95     b3 += W3 * in5 - W1 * in7;
  96
  97     blk[off + 0*8] = ((a0 + b0) >> COL_SHIFT) as i16;
  98     blk[off + 7*8] = ((a0 - b0) >> COL_SHIFT) as i16;
  99     blk[off + 1*8] = ((a1 + b1) >> COL_SHIFT) as i16;
 100     blk[off + 6*8] = ((a1 - b1) >> COL_SHIFT) as i16;
 101     blk[off + 2*8] = ((a2 + b2) >> COL_SHIFT) as i16;
 102     blk[off + 5*8] = ((a2 - b2) >> COL_SHIFT) as i16;
 103     blk[off + 3*8] = ((a3 + b3) >> COL_SHIFT) as i16;
 104     blk[off + 4*8] = ((a3 - b3) >> COL_SHIFT) as i16;
 105 }
 106
 107 #[allow(dead_code)]
 108 pub fn h263_idct(blk: &mut [i16; 64]) {
 109     for i in 0..8 { idct_row(&mut blk[i*8..(i+1)*8]); }
 110     for i in 0..8 { idct_col(blk, i); }
 111 }*/
 112
 113 const W1: i32 = 2841;
 114 const W2: i32 = 2676;
 115 const W3: i32 = 2408;
 116 const W5: i32 = 1609;
 117 const W6: i32 = 1108;
 118 const W7: i32 =  565;
 119 const W8: i32 =  181;
 120
 121 const ROW_SHIFT: u8 = 8;
 122 const COL_SHIFT: u8 = 14;
 123
 124 fn idct_row(row: &mut [i16]) {
 125     let in0 = ((row[0] as i32) << 11) + (1 << (ROW_SHIFT - 1));
 126     let in1 =  (row[4] as i32) << 11;
 127     let in2 =   row[6] as i32;
 128     let in3 =   row[2] as i32;
 129     let in4 =   row[1] as i32;
 130     let in5 =   row[7] as i32;
 131     let in6 =   row[5] as i32;
 132     let in7 =   row[3] as i32;
 133
 134     let tmp = W7 * (in4 + in5);
 135     let a4 = tmp + (W1 - W7) * in4;
 136     let a5 = tmp - (W1 + W7) * in5;
 137
 138     let tmp = W3 * (in6 + in7);
 139     let a6 = tmp - (W3 - W5) * in6;
 140     let a7 = tmp - (W3 + W5) * in7;
 141
 142     let tmp = in0 + in1;
 143
 144     let a0 = in0 - in1;
 145     let t1 = W6 * (in2 + in3);
 146     let a2 = t1 - (W2 + W6) * in2;
 147     let a3 = t1 + (W2 - W6) * in3;
 148     let b1 = a4 + a6;
 149
 150     let b4 = a4 - a6;
 151     let t2 = a5 - a7;
 152     let b6 = a5 + a7;
 153     let b7 = tmp + a3;
 154     let b5 = tmp - a3;
 155     let b3 = a0 + a2;
 156     let b0 = a0 - a2;
 157     let b2 = (W8 * (b4 + t2) + 128) >> 8;
 158     let b4 = (W8 * (b4 - t2) + 128) >> 8;
 159
 160     row[0] = ((b7 + b1) >> ROW_SHIFT) as i16;
 161     row[7] = ((b7 - b1) >> ROW_SHIFT) as i16;
 162     row[1] = ((b3 + b2) >> ROW_SHIFT) as i16;
 163     row[6] = ((b3 - b2) >> ROW_SHIFT) as i16;
 164     row[2] = ((b0 + b4) >> ROW_SHIFT) as i16;
 165     row[5] = ((b0 - b4) >> ROW_SHIFT) as i16;
 166     row[3] = ((b5 + b6) >> ROW_SHIFT) as i16;
 167     row[4] = ((b5 - b6) >> ROW_SHIFT) as i16;
 168 }
 169
 170 fn idct_col(blk: &mut [i16; 64], off: usize) {
 171     let in0 = ((blk[off + 0*8] as i32) << 8) + (1 << (COL_SHIFT - 1));
 172     let in1 =  (blk[off + 4*8] as i32) << 8;
 173     let in2 =   blk[off + 6*8] as i32;
 174     let in3 =   blk[off + 2*8] as i32;
 175     let in4 =   blk[off + 1*8] as i32;
 176     let in5 =   blk[off + 7*8] as i32;
 177     let in6 =   blk[off + 5*8] as i32;
 178     let in7 =   blk[off + 3*8] as i32;
 179
 180     let tmp = W7 * (in4 + in5);
 181     let a4 = (tmp + (W1 - W7) * in4) >> 3;
 182     let a5 = (tmp - (W1 + W7) * in5) >> 3;
 183
 184     let tmp = W3 * (in6 + in7);
 185     let a6 = (tmp - (W3 - W5) * in6) >> 3;
 186     let a7 = (tmp - (W3 + W5) * in7) >> 3;
 187
 188     let tmp = in0 + in1;
 189
 190     let a0 = in0 - in1;
 191     let t1 = W6 * (in2 + in3);
 192     let a2 = (t1 - (W2 + W6) * in2) >> 3;
 193     let a3 = (t1 + (W2 - W6) * in3) >> 3;
 194     let b1 = a4 + a6;
 195
 196     let b4 = a4 - a6;
 197     let t2 = a5 - a7;
 198     let b6 = a5 + a7;
 199     let b7 = tmp + a3;
 200     let b5 = tmp - a3;
 201     let b3 = a0 + a2;
 202     let b0 = a0 - a2;
 203     let b2 = (W8 * (b4 + t2) + 128) >> 8;
 204     let b4 = (W8 * (b4 - t2) + 128) >> 8;
 205
 206     blk[off + 0*8] = ((b7 + b1) >> COL_SHIFT) as i16;
 207     blk[off + 7*8] = ((b7 - b1) >> COL_SHIFT) as i16;
 208     blk[off + 1*8] = ((b3 + b2) >> COL_SHIFT) as i16;
 209     blk[off + 6*8] = ((b3 - b2) >> COL_SHIFT) as i16;
 210     blk[off + 2*8] = ((b0 + b4) >> COL_SHIFT) as i16;
 211     blk[off + 5*8] = ((b0 - b4) >> COL_SHIFT) as i16;
 212     blk[off + 3*8] = ((b5 + b6) >> COL_SHIFT) as i16;
 213     blk[off + 4*8] = ((b5 - b6) >> COL_SHIFT) as i16;
 214 }
 215
 216 #[allow(dead_code)]
 217 pub fn h263_idct(blk: &mut [i16; 64]) {
 218     for i in 0..8 { idct_row(&mut blk[i*8..(i+1)*8]); }
 219     for i in 0..8 { idct_col(blk, i); }
 220 }
 221
 222 fn h263_interp00(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 223 {
 224     let mut didx = 0;
 225     let mut sidx = 0;
 226     for _ in 0..bh {
 227         for x in 0..bw { dst[didx + x] = src[sidx + x]; }
 228         didx += dstride;
 229         sidx += sstride;
 230     }
 231 }
 232
 233 fn h263_interp01(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 234 {
 235     let mut didx = 0;
 236     let mut sidx = 0;
 237     for _ in 0..bh {
 238         for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + 1] as u16) + 1) >> 1) as u8; }
 239         didx += dstride;
 240         sidx += sstride;
 241     }
 242 }
 243
 244 fn h263_interp10(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 245 {
 246     let mut didx = 0;
 247     let mut sidx = 0;
 248     for _ in 0..bh {
 249         for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + sstride] as u16) + 1) >> 1) as u8; }
 250         didx += dstride;
 251         sidx += sstride;
 252     }
 253 }
 254
 255 fn h263_interp11(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 256 {
 257     let mut didx = 0;
 258     let mut sidx = 0;
 259     for _ in 0..bh {
 260         for x in 0..bw {
 261             dst[didx + x] = (((src[sidx + x] as u16) +
 262                               (src[sidx + x + 1] as u16) +
 263                               (src[sidx + x + sstride] as u16) +
 264                               (src[sidx + x + sstride + 1] as u16) + 2) >> 2) as u8;
 265         }
 266         didx += dstride;
 267         sidx += sstride;
 268     }
 269 }
 270
 271 pub const H263_INTERP_FUNCS: &[fn(&mut [u8], usize, &[u8], usize, usize, usize)] = &[
 272         h263_interp00, h263_interp01, h263_interp10, h263_interp11 ];
 273
 274 fn h263_interp00_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 275 {
 276     let mut didx = 0;
 277     let mut sidx = 0;
 278     for _ in 0..bh {
 279         for x in 0..bw {
 280             let a = dst[didx + x] as u16;
 281             let b = src[sidx + x] as u16;
 282             dst[didx + x] = ((a + b + 1) >> 1) as u8;
 283         }
 284         didx += dstride;
 285         sidx += sstride;
 286     }
 287 }
 288
 289 fn h263_interp01_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 290 {
 291     let mut didx = 0;
 292     let mut sidx = 0;
 293     for _ in 0..bh {
 294         for x in 0..bw {
 295             let a = dst[didx + x] as u16;
 296             let b = ((src[sidx + x] as u16) + (src[sidx + x + 1] as u16) + 1) >> 1;
 297             dst[didx + x] = ((a + b + 1) >> 1) as u8;
 298         }
 299         didx += dstride;
 300         sidx += sstride;
 301     }
 302 }
 303
 304 fn h263_interp10_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 305 {
 306     let mut didx = 0;
 307     let mut sidx = 0;
 308     for _ in 0..bh {
 309         for x in 0..bw {
 310             let a = dst[didx + x] as u16;
 311             let b = ((src[sidx + x] as u16) + (src[sidx + x + sstride] as u16) + 1) >> 1;
 312             dst[didx + x] = ((a + b + 1) >> 1) as u8;
 313         }
 314         didx += dstride;
 315         sidx += sstride;
 316     }
 317 }
 318
 319 fn h263_interp11_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
 320 {
 321     let mut didx = 0;
 322     let mut sidx = 0;
 323     for _ in 0..bh {
 324         for x in 0..bw {
 325             let a = dst[didx + x] as u16;
 326             let b = ((src[sidx + x] as u16) +
 327                      (src[sidx + x + 1] as u16) +
 328                      (src[sidx + x + sstride] as u16) +
 329                      (src[sidx + x + sstride + 1] as u16) + 2) >> 2;
 330             dst[didx + x] = ((a + b + 1) >> 1) as u8;
 331         }
 332         didx += dstride;
 333         sidx += sstride;
 334     }
 335 }
 336
 337 pub const H263_INTERP_AVG_FUNCS: &[fn(&mut [u8], usize, &[u8], usize, usize, usize)] = &[
 338         h263_interp00_avg, h263_interp01_avg, h263_interp10_avg, h263_interp11_avg ];
 339
 340 pub struct H263BlockDSP { }
 341
 342 impl H263BlockDSP {
 343     pub fn new() -> Self {
 344         H263BlockDSP { }
 345     }
 346 }
 347
 348 fn deblock_hor(buf: &mut NAVideoBuffer<u8>, comp: usize, q: u8, off: usize) {
 349     let stride = buf.get_stride(comp);
 350     let mut dptr = buf.get_data_mut();
 351     let buf = dptr.as_mut_slice();
 352     for x in 0..8 {
 353         let a = buf[off - 2 * stride + x] as i16;
 354         let b = buf[off - 1 * stride + x] as i16;
 355         let c = buf[off + 0 * stride + x] as i16;
 356         let d = buf[off + 1 * stride + x] as i16;
 357         let diff = ((a - d) * 3 + (c - b) * 8) >> 4;
 358         if (diff != 0) && (diff >= -32) && (diff < 32) {
 359             let d0 = diff.abs() * 2 - (q as i16);
 360             let d1 = if d0 < 0 { 0 } else { d0 };
 361             let d2 = diff.abs() - d1;
 362             let d3 = if d2 < 0 { 0 } else { d2 };
 363
 364             let delta = if diff < 0 { -d3 } else { d3 };
 365
 366             let b1 = b + delta;
 367             if      b1 < 0   { buf[off - 1 * stride + x] = 0; }
 368             else if b1 > 255 { buf[off - 1 * stride + x] = 0xFF; }
 369             else             { buf[off - 1 * stride + x] = b1 as u8; }
 370             let c1 = c - delta;
 371             if      c1 < 0   { buf[off + x] = 0; }
 372             else if c1 > 255 { buf[off + x] = 0xFF; }
 373             else             { buf[off + x] = c1 as u8; }
 374         }
 375     }
 376 }
 377
 378 fn deblock_ver(buf: &mut NAVideoBuffer<u8>, comp: usize, q: u8, off: usize) {
 379     let stride = buf.get_stride(comp);
 380     let mut dptr = buf.get_data_mut();
 381     let buf = dptr.as_mut_slice();
 382     for y in 0..8 {
 383         let a = buf[off - 2 + y * stride] as i16;
 384         let b = buf[off - 1 + y * stride] as i16;
 385         let c = buf[off + 0 + y * stride] as i16;
 386         let d = buf[off + 1 + y * stride] as i16;
 387         let diff = ((a - d) * 3 + (c - b) * 8) >> 4;
 388         if (diff != 0) && (diff >= -32) && (diff < 32) {
 389             let d0 = diff.abs() * 2 - (q as i16);
 390             let d1 = if d0 < 0 { 0 } else { d0 };
 391             let d2 = diff.abs() - d1;
 392             let d3 = if d2 < 0 { 0 } else { d2 };
 393
 394             let delta = if diff < 0 { -d3 } else { d3 };
 395
 396             let b1 = b + delta;
 397             if      b1 < 0   { buf[off - 1 + y * stride] = 0; }
 398             else if b1 > 255 { buf[off - 1 + y * stride] = 0xFF; }
 399             else             { buf[off - 1 + y * stride] = b1 as u8; }
 400             let c1 = c - delta;
 401             if      c1 < 0   { buf[off + y * stride] = 0; }
 402             else if c1 > 255 { buf[off + y * stride] = 0xFF; }
 403             else             { buf[off + y * stride] = c1 as u8; }
 404         }
 405     }
 406 }
 407
 408 pub fn h263_filter_row(buf: &mut NAVideoBuffer<u8>, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) {
 409     let stride  = buf.get_stride(0);
 410     let mut off = buf.get_offset(0) + mb_y * 16 * stride;
 411     for mb_x in 0..mb_w {
 412         let coff = off;
 413         let coded0 = cbpi.is_coded(mb_x, 0);
 414         let coded1 = cbpi.is_coded(mb_x, 1);
 415         let q = cbpi.get_q(mb_w + mb_x);
 416         if mb_y != 0 {
 417                 if coded0 && cbpi.is_coded_top(mb_x, 0) { deblock_hor(buf, 0, q, coff); }
 418                 if coded1 && cbpi.is_coded_top(mb_x, 1) { deblock_hor(buf, 0, q, coff + 8); }
 419         }
 420         let coff = off + 8 * stride;
 421         if cbpi.is_coded(mb_x, 2) && coded0 { deblock_hor(buf, 0, q, coff); }
 422         if cbpi.is_coded(mb_x, 3) && coded1 { deblock_hor(buf, 0, q, coff + 8); }
 423         off += 16;
 424     }
 425     let mut leftt = false;
 426     let mut leftc = false;
 427     let mut off = buf.get_offset(0) + mb_y * 16 * stride;
 428     for mb_x in 0..mb_w {
 429         let ctop0 = cbpi.is_coded_top(mb_x, 0);
 430         let ctop1 = cbpi.is_coded_top(mb_x, 0);
 431         let ccur0 = cbpi.is_coded(mb_x, 0);
 432         let ccur1 = cbpi.is_coded(mb_x, 1);
 433         let q = cbpi.get_q(mb_w + mb_x);
 434         if mb_y != 0 {
 435                 let coff = off - 8 * stride;
 436                 let qtop = cbpi.get_q(mb_x);
 437                 if leftt && ctop0 { deblock_ver(buf, 0, qtop, coff); }
 438                 if ctop0 && ctop1 { deblock_ver(buf, 0, qtop, coff + 8); }
 439         }
 440         if leftc && ccur0 { deblock_ver(buf, 0, q, off); }
 441         if ccur0 && ccur1 { deblock_ver(buf, 0, q, off + 8); }
 442         leftt = ctop1;
 443         leftc = ccur1;
 444         off += 16;
 445     }
 446     let strideu = buf.get_stride(1);
 447     let stridev = buf.get_stride(2);
 448     let offu = buf.get_offset(1) + mb_y * 8 * strideu;
 449     let offv = buf.get_offset(2) + mb_y * 8 * stridev;
 450     if mb_y != 0 {
 451         for mb_x in 0..mb_w {
 452                 let ctu = cbpi.is_coded_top(mb_x, 4);
 453                 let ccu = cbpi.is_coded(mb_x, 4);
 454                 let ctv = cbpi.is_coded_top(mb_x, 5);
 455                 let ccv = cbpi.is_coded(mb_x, 5);
 456                 let q = cbpi.get_q(mb_w + mb_x);
 457                 if ctu && ccu { deblock_hor(buf, 1, q, offu + mb_x * 8); }
 458                 if ctv && ccv { deblock_hor(buf, 2, q, offv + mb_x * 8); }
 459         }
 460         let mut leftu = false;
 461         let mut leftv = false;
 462         let offu = buf.get_offset(1) + (mb_y - 1) * 8 * strideu;
 463         let offv = buf.get_offset(2) + (mb_y - 1) * 8 * stridev;
 464         for mb_x in 0..mb_w {
 465                 let ctu = cbpi.is_coded_top(mb_x, 4);
 466                 let ctv = cbpi.is_coded_top(mb_x, 5);
 467                 let qt = cbpi.get_q(mb_x);
 468                 if leftu && ctu { deblock_ver(buf, 1, qt, offu + mb_x * 8); }
 469                 if leftv && ctv { deblock_ver(buf, 2, qt, offv + mb_x * 8); }
 470                 leftu = ctu;
 471                 leftv = ctv;
 472         }
 473     }
 474 }
 475
 476 impl BlockDSP for H263BlockDSP {
 477     fn idct(&self, blk: &mut [i16; 64]) {
 478         h263_idct(blk)
 479     }
 480     fn copy_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: &NAVideoBuffer<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
 481         let srcx = ((mv.x >> 1) as isize) + (xpos as isize);
 482         let srcy = ((mv.y >> 1) as isize) + (ypos as isize);
 483         let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 484
 485         blockdsp::copy_blocks(dst, src, xpos, ypos, srcx, srcy, w, h, 0, 1, mode, H263_INTERP_FUNCS);
 486     }
 487     fn avg_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: &NAVideoBuffer<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
 488         let srcx = ((mv.x >> 1) as isize) + (xpos as isize);
 489         let srcy = ((mv.y >> 1) as isize) + (ypos as isize);
 490         let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
 491
 492         blockdsp::copy_blocks(dst, src, xpos, ypos, srcx, srcy, w, h, 0, 1, mode, H263_INTERP_AVG_FUNCS);
 493     }
 494     fn filter_row(&self, buf: &mut NAVideoBuffer<u8>, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) {
 495         h263_filter_row(buf, mb_y, mb_w, cbpi)
 496     }
 497 }