nihav-realmedia/src/codecs/rv34dsp.rs

   1 #[allow(dead_code)]
   2 #[derive(Debug,Clone,Copy)]
   3 pub enum PredType4x4 {
   4     Ver,
   5     Hor,
   6     DC,
   7     DiagDownLeft,
   8     DiagDownRight,
   9     VerRight,
  10     HorDown,
  11     VerLeft,
  12     HorUp,
  13     LeftDC,
  14     TopDC,
  15     DC128,
  16     DiagDownLeftNoDown,
  17     HorUpNoDown,
  18     VerLeftNoDown
  19 }
  20
  21 #[allow(dead_code)]
  22 #[derive(Debug,Clone,Copy)]
  23 pub enum PredType8x8 {
  24     DC,
  25     Hor,
  26     Ver,
  27     Plane,
  28     LeftDC,
  29     TopDC,
  30     DC128
  31 }
  32
  33 pub struct RV34CommonDSP {
  34     pub ipred4x4:   [fn(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]); 15],
  35     pub ipred8x8:   [fn(buf: &mut [u8], idx: usize, stride: usize); 7],
  36     pub ipred16x16: [fn(buf: &mut [u8], idx: usize, stride: usize); 7],
  37 }
  38
  39 fn row_transform(src: &[i16], dst: &mut [i32]) {
  40     for i in 0..4 {
  41         let z0 = 13 * ((src[i + 4*0] as i32) + (src[i + 4*2] as i32));
  42         let z1 = 13 * ((src[i + 4*0] as i32) - (src[i + 4*2] as i32));
  43         let z2 =  7 *  (src[i + 4*1] as i32) - 17 * (src[i + 4*3] as i32);
  44         let z3 = 17 *  (src[i + 4*1] as i32) +  7 * (src[i + 4*3] as i32);
  45         dst[4 * i + 0] = z0 + z3;
  46         dst[4 * i + 1] = z1 + z2;
  47         dst[4 * i + 2] = z1 - z2;
  48         dst[4 * i + 3] = z0 - z3;
  49     }
  50 }
  51
  52 fn clip8(a: i16) -> u8 {
  53     if a < 0 { 0 }
  54     else if a > 255 { 255 }
  55     else { a as u8 }
  56 }
  57
  58 #[inline(always)]
  59 fn mclip8(a: i32) -> u8 {
  60     if (a as u32) > 255 { !(a >> 16) as u8 }
  61     else { a as u8 }
  62 }
  63
  64 impl RV34CommonDSP {
  65     pub fn new() -> Self {
  66         Self {
  67             ipred4x4:   IPRED_FUNCS4X4,
  68             ipred8x8:   IPRED_FUNCS8X8,
  69             ipred16x16: IPRED_FUNCS16X16,
  70         }
  71     }
  72     pub fn add_coeffs(&self, dst: &mut [u8], idx: usize, stride: usize, coeffs: &[i16]) {
  73         let out = &mut dst[idx..][..stride * 3 + 4];
  74         let mut sidx: usize = 0;
  75         for el in out.chunks_mut(stride).take(4) {
  76             assert!(el.len() >= 4);
  77             el[0] = mclip8((el[0] as i32) + (coeffs[0 + sidx] as i32));
  78             el[1] = mclip8((el[1] as i32) + (coeffs[1 + sidx] as i32));
  79             el[2] = mclip8((el[2] as i32) + (coeffs[2 + sidx] as i32));
  80             el[3] = mclip8((el[3] as i32) + (coeffs[3 + sidx] as i32));
  81             sidx += 4;
  82         }
  83     }
  84     pub fn transform(&self, coeffs: &mut [i16]) {
  85         let mut tmp: [i32; 16] = [0; 16];
  86         row_transform(coeffs, &mut tmp);
  87         for i in 0..4 {
  88             let z0 = 13*(tmp[4*0+i] +    tmp[4*2+i]) + 0x200;
  89             let z1 = 13*(tmp[4*0+i] -    tmp[4*2+i]) + 0x200;
  90             let z2 =  7* tmp[4*1+i] - 17*tmp[4*3+i];
  91             let z3 = 17* tmp[4*1+i] +  7*tmp[4*3+i];
  92             coeffs[i * 4 + 0] = ((z0 + z3) >> 10) as i16;
  93             coeffs[i * 4 + 1] = ((z1 + z2) >> 10) as i16;
  94             coeffs[i * 4 + 2] = ((z1 - z2) >> 10) as i16;
  95             coeffs[i * 4 + 3] = ((z0 - z3) >> 10) as i16;
  96         }
  97     }
  98     pub fn transform_dc(&self, coeffs: &mut [i16]) {
  99         let val = (((coeffs[0] as i32) * 13 * 13 + 0x200) >> 10) as i16;
 100         for i in 0..16 { coeffs[i] = val; }
 101     }
 102     pub fn transform16(&self, coeffs: &mut [i16]) {
 103         let mut tmp: [i32; 16] = [0; 16];
 104         row_transform(coeffs, &mut tmp);
 105         for i in 0..4 {
 106             let z0 = 39*(tmp[4*0+i] +    tmp[4*2+i]);
 107             let z1 = 39*(tmp[4*0+i] -    tmp[4*2+i]);
 108             let z2 = 21* tmp[4*1+i] - 51*tmp[4*3+i];
 109             let z3 = 51* tmp[4*1+i] + 21*tmp[4*3+i];
 110
 111             coeffs[i * 4 + 0] = ((z0 + z3) >> 11) as i16;
 112             coeffs[i * 4 + 1] = ((z1 + z2) >> 11) as i16;
 113             coeffs[i * 4 + 2] = ((z1 - z2) >> 11) as i16;
 114             coeffs[i * 4 + 3] = ((z0 - z3) >> 11) as i16;
 115         }
 116     }
 117     pub fn transform16_dc(&self, coeffs: &mut [i16]) {
 118         let val = (((coeffs[0] as i32) * 13 * 13 * 3) >> 11) as i16;
 119         for i in 0..16 { coeffs[i] = val; }
 120     }
 121     pub fn weight(&self, dst: &mut [u8], mut didx: usize, dstride: usize,
 122               src: &[u8], mut sidx: usize, sstride: usize, ratio1: u32, ratio2: u32,
 123               size: usize) {
 124         for _ in 0..size {
 125             for x in 0..size {
 126                 dst[didx + x] = (((((dst[didx + x] as u32) * ratio1) >> 9)
 127                                 + (((src[sidx + x] as u32) * ratio2) >> 9) + 0x10) >> 5) as u8;
 128             }
 129             didx += dstride;
 130             sidx += sstride;
 131         }
 132     }
 133     pub fn avg(&self, dst: &mut [u8], mut didx: usize, dstride: usize,
 134                src: &[u8], mut sidx: usize, sstride: usize,
 135                size: usize) {
 136         for _ in 0..size {
 137             for x in 0..size {
 138                 dst[didx + x] = (((dst[didx + x] as u16) + (src[sidx + x] as u16) + 1) >> 1) as u8;
 139             }
 140             didx += dstride;
 141             sidx += sstride;
 142         }
 143     }
 144 }
 145
 146 fn ipred_dc128(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize) {
 147     for _ in 0..bsize {
 148         for x in 0..bsize { buf[idx + x] = 128; }
 149         idx += stride;
 150     }
 151 }
 152 fn ipred_ver(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize) {
 153     let oidx = idx - stride;
 154     for _ in 0..bsize {
 155         for x in 0..bsize { buf[idx + x] = buf[oidx + x]; }
 156         idx += stride;
 157     }
 158 }
 159 fn ipred_hor(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize) {
 160     for _ in 0..bsize {
 161         for x in 0..bsize { buf[idx + x] = buf[idx - 1]; }
 162         idx += stride;
 163     }
 164 }
 165 fn ipred_dc(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize, shift: u8) {
 166     let mut adc: u16 = 0;
 167     for i in 0..bsize { adc += buf[idx - stride + i] as u16; }
 168     for i in 0..bsize { adc += buf[idx - 1 + i * stride] as u16; }
 169     let dc = ((adc + (1 << (shift - 1))) >> shift) as u8;
 170
 171     for _ in 0..bsize {
 172         for x in 0..bsize { buf[idx + x] = dc; }
 173         idx += stride;
 174     }
 175 }
 176 fn ipred_left_dc(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize, shift: u8) {
 177     let mut adc: u16 = 0;
 178     for i in 0..bsize { adc += buf[idx - 1 + i * stride] as u16; }
 179     let dc = ((adc + (1 << (shift - 1))) >> shift) as u8;
 180
 181     for _ in 0..bsize {
 182         for x in 0..bsize { buf[idx + x] = dc; }
 183         idx += stride;
 184     }
 185 }
 186 fn ipred_top_dc(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize, shift: u8) {
 187     let mut adc: u16 = 0;
 188     for i in 0..bsize { adc += buf[idx - stride + i] as u16; }
 189     let dc = ((adc + (1 << (shift - 1))) >> shift) as u8;
 190
 191     for _ in 0..bsize {
 192         for x in 0..bsize { buf[idx + x] = dc; }
 193         idx += stride;
 194     }
 195 }
 196
 197 fn load_top(dst: &mut [u16], buf: &mut [u8], idx: usize, stride: usize, len: usize) {
 198     for i in 0..len { dst[i] = buf[idx - stride + i] as u16; }
 199 }
 200 fn load_left(dst: &mut [u16], buf: &mut [u8], idx: usize, stride: usize, len: usize) {
 201     for i in 0..len { dst[i] = buf[idx - 1 + i * stride] as u16; }
 202 }
 203
 204 fn ipred_4x4_ver(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 205     ipred_ver(buf, idx, stride, 4);
 206 }
 207 fn ipred_4x4_hor(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 208     ipred_hor(buf, idx, stride, 4);
 209 }
 210 fn ipred_4x4_diag_down_left(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]) {
 211     let mut t: [u16; 8] = [0; 8];
 212     let mut l: [u16; 8] = [0; 8];
 213     load_top(&mut t, buf, idx, stride, 4);
 214     for i in 0..4 { t[i + 4] = tr[i] as u16; }
 215     load_left(&mut l, buf, idx, stride, 8);
 216     let dst = &mut buf[idx..];
 217
 218     dst[0 + 0 * stride] = ((t[0] + t[2] + 2*t[1] + 2 + l[0] + l[2] + 2*l[1] + 2) >> 3) as u8;
 219     let pix = ((t[1] + t[3] + 2*t[2] + 2 + l[1] + l[3] + 2*l[2] + 2) >> 3) as u8;
 220     dst[1 + 0 * stride] = pix;
 221     dst[0 + 1 * stride] = pix;
 222     let pix = ((t[2] + t[4] + 2*t[3] + 2 + l[2] + l[4] + 2*l[3] + 2) >> 3) as u8;
 223     dst[2 + 0 * stride] = pix;
 224     dst[1 + 1 * stride] = pix;
 225     dst[0 + 2 * stride] = pix;
 226     let pix = ((t[3] + t[5] + 2*t[4] + 2 + l[3] + l[5] + 2*l[4] + 2) >> 3) as u8;
 227     dst[3 + 0 * stride] = pix;
 228     dst[2 + 1 * stride] = pix;
 229     dst[1 + 2 * stride] = pix;
 230     dst[0 + 3 * stride] = pix;
 231     let pix = ((t[4] + t[6] + 2*t[5] + 2 + l[4] + l[6] + 2*l[5] + 2) >> 3) as u8;
 232     dst[3 + 1 * stride] = pix;
 233     dst[2 + 2 * stride] = pix;
 234     dst[1 + 3 * stride] = pix;
 235     let pix = ((t[5] + t[7] + 2*t[6] + 2 + l[5] + l[7] + 2*l[6] + 2) >> 3) as u8;
 236     dst[3 + 2 * stride] = pix;
 237     dst[2 + 3 * stride] = pix;
 238     dst[3 + 3 * stride] = ((t[6] + t[7] + 1 + l[6] + l[7] + 1) >> 2) as u8;
 239 }
 240 fn ipred_4x4_diag_down_left_nodown(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]) {
 241     let mut t: [u16; 8] = [0; 8];
 242     let mut l: [u16; 4] = [0; 4];
 243     load_top(&mut t, buf, idx, stride, 4);
 244     for i in 0..4 { t[i + 4] = tr[i] as u16; }
 245     load_left(&mut l, buf, idx, stride, 4);
 246     let dst = &mut buf[idx..];
 247
 248     dst[0 + 0 * stride] = ((t[0] + t[2] + 2*t[1] + 2 + l[0] + l[2] + 2*l[1] + 2) >> 3) as u8;
 249     let pix = ((t[1] + t[3] + 2*t[2] + 2 + l[1] + l[3] + 2*l[2] + 2) >> 3) as u8;
 250     dst[1 + 0 * stride] = pix;
 251     dst[0 + 1 * stride] = pix;
 252     let pix = ((t[2] + t[4] + 2*t[3] + 2 + l[2] + 3*l[3] + 2) >> 3) as u8;
 253     dst[2 + 0 * stride] = pix;
 254     dst[1 + 1 * stride] = pix;
 255     dst[0 + 2 * stride] = pix;
 256     let pix = ((t[3] + t[5] + 2*t[4] + 2 + l[3]*4 + 2) >> 3) as u8;
 257     dst[3 + 0 * stride] = pix;
 258     dst[2 + 1 * stride] = pix;
 259     dst[1 + 2 * stride] = pix;
 260     dst[0 + 3 * stride] = pix;
 261     let pix = ((t[4] + t[6] + 2*t[5] + 2 + l[3]*4 + 2) >> 3) as u8;
 262     dst[3 + 1 * stride] = pix;
 263     dst[2 + 2 * stride] = pix;
 264     dst[1 + 3 * stride] = pix;
 265     let pix = ((t[5] + t[7] + 2*t[6] + 2 + l[3]*4 + 2) >> 3) as u8;
 266     dst[3 + 2 * stride] = pix;
 267     dst[2 + 3 * stride] = pix;
 268     dst[3 + 3 * stride] = ((t[6] + t[7] + 1 + 2*l[3] + 1) >> 2) as u8;
 269 }
 270 fn ipred_4x4_diag_down_right(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 271     let mut t: [u16; 5] = [0; 5];
 272     let mut l: [u16; 5] = [0; 5];
 273     load_top(&mut t, buf, idx - 1, stride, 5);
 274     load_left(&mut l, buf, idx - stride, stride, 5);
 275     let dst = &mut buf[idx..];
 276
 277     for j in 0..4 {
 278         for i in 0..j {
 279             dst[i + j * stride] = ((l[j - i - 1] + 2 * l[j - i] + l[j - i + 1] + 2) >> 2) as u8;
 280         }
 281         dst[j + j * stride] = ((l[1] + 2 * l[0] + t[1] + 2) >> 2) as u8;
 282         for i in (j+1)..4 {
 283             dst[i + j * stride] = ((t[i - j - 1] + 2 * t[i - j] + t[i - j + 1] + 2) >> 2) as u8;
 284         }
 285     }
 286 }
 287 fn ipred_4x4_ver_right(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 288     let mut t: [u16; 5] = [0; 5];
 289     let mut l: [u16; 5] = [0; 5];
 290     load_top(&mut t, buf, idx - 1, stride, 5);
 291     load_left(&mut l, buf, idx - stride, stride, 5);
 292     let dst = &mut buf[idx..];
 293
 294     for j in 0..4 {
 295         for i in 0..4 {
 296             let zvr = ((2 * i) as i8) - (j as i8);
 297             let pix;
 298             if zvr >= 0 {
 299                 if (zvr & 1) == 0 {
 300                     pix = (t[i - (j >> 1)] + t[i - (j >> 1) + 1] + 1) >> 1;
 301                 } else {
 302                     pix = (t[i - (j >> 1) - 1] + 2 * t[i - (j >> 1)] + t[i - (j >> 1) + 1] + 2) >> 2;
 303                 }
 304             } else {
 305                 if zvr == -1 {
 306                     pix = (l[1] + 2 * l[0] + t[1] + 2) >> 2;
 307                 } else {
 308                     pix = (l[j] + 2 * l[j - 1] + l[j - 2] + 2) >> 2;
 309                 }
 310             }
 311             dst[i + j * stride] = pix as u8;
 312         }
 313     }
 314 }
 315 fn ipred_4x4_ver_left_common(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8], no_down: bool) {
 316     let mut t: [u16; 8] = [0; 8];
 317     let mut l: [u16; 5] = [0; 5];
 318     load_top(&mut t, buf, idx, stride, 4);
 319     for i in 0..4 { t[i + 4] = tr[i] as u16; }
 320     load_left(&mut l, buf, idx, stride, 4);
 321     l[4] = if no_down { l[3] } else { buf[idx - 1 + 4 * stride] as u16 };
 322     let dst = &mut buf[idx..];
 323
 324     dst[0 + 0 * stride] = ((2*t[0] + 2*t[1] + l[1] + 2*l[2] + l[3] + 4) >> 3) as u8;
 325     let pix = ((t[1] + t[2] + 1) >> 1) as u8;
 326     dst[1 + 0 * stride] = pix;
 327     dst[0 + 2 * stride] = pix;
 328     let pix = ((t[2] + t[3] + 1) >> 1) as u8;
 329     dst[2 + 0 * stride] = pix;
 330     dst[1 + 2 * stride] = pix;
 331     let pix = ((t[3] + t[4] + 1) >> 1) as u8;
 332     dst[3 + 0 * stride] = pix;
 333     dst[2 + 2 * stride] = pix;
 334     dst[3 + 2 * stride] = ((t[4] + t[5] + 1) >> 1) as u8;
 335     dst[0 + 1 * stride] = ((t[0] + 2*t[1] + t[2] + l[2] + 2*l[3] + l[4] + 4) >> 3) as u8;
 336     let pix = ((t[1] + 2*t[2] + t[3] + 2) >> 2) as u8;
 337     dst[1 + 1 * stride] = pix;
 338     dst[0 + 3 * stride] = pix;
 339     let pix = ((t[2] + 2*t[3] + t[4] + 2) >> 2) as u8;
 340     dst[2 + 1 * stride] = pix;
 341     dst[1 + 3 * stride] = pix;
 342     let pix = ((t[3] + 2*t[4] + t[5] + 2) >> 2) as u8;
 343     dst[3 + 1 * stride] = pix;
 344     dst[2 + 3 * stride] = pix;
 345     dst[3 + 3 * stride] = ((t[4] + 2*t[5] + t[6] + 2) >> 2) as u8;
 346 }
 347
 348 fn ipred_4x4_ver_left(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]) {
 349     ipred_4x4_ver_left_common(buf, idx, stride, tr, false);
 350 }
 351 fn ipred_4x4_ver_left_nodown(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]) {
 352     ipred_4x4_ver_left_common(buf, idx, stride, tr, true);
 353 }
 354 fn ipred_4x4_hor_down(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 355     let mut t: [u16; 5] = [0; 5];
 356     let mut l: [u16; 5] = [0; 5];
 357     load_top(&mut t, buf, idx - 1, stride, 5);
 358     load_left(&mut l, buf, idx - stride, stride, 5);
 359     let dst = &mut buf[idx..];
 360
 361     for j in 0..4 {
 362         for i in 0..4 {
 363             let zhd = ((2 * j) as i8) - (i as i8);
 364             let pix;
 365             if zhd >= 0 {
 366                 if (zhd & 1) == 0 {
 367                     pix = (l[j - (i >> 1)] + l[j - (i >> 1) + 1] + 1) >> 1;
 368                 } else {
 369                     pix = (l[j - (i >> 1) - 1] + 2 * l[j - (i >> 1)] + l[j - (i >> 1) + 1] + 2) >> 2;
 370                 }
 371             } else {
 372                 if zhd == -1 {
 373                     pix = (l[1] + 2 * l[0] + t[1] + 2) >> 2;
 374                 } else {
 375                     pix = (t[i - 2] + 2 * t[i - 1] + t[i] + 2) >> 2;
 376                 }
 377             }
 378             dst[i + j * stride] = pix as u8;
 379         }
 380     }
 381 }
 382 fn ipred_4x4_hor_up(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]) {
 383     let mut t: [u16; 8] = [0; 8];
 384     let mut l: [u16; 8] = [0; 8];
 385     load_top(&mut t, buf, idx, stride, 4);
 386     for i in 0..4 { t[i + 4] = tr[i] as u16; }
 387     load_left(&mut l, buf, idx, stride, 8);
 388     let dst = &mut buf[idx..];
 389
 390     dst[0 + 0 * stride] = ((t[1] + 2*t[2] + t[3] + 2*l[0] + 2*l[1] + 4) >> 3) as u8;
 391     dst[1 + 0 * stride] = ((t[2] + 2*t[3] + t[4] + l[0] + 2*l[1] + l[2] + 4) >> 3) as u8;
 392     let pix = ((t[3] + 2*t[4] + t[5] + 2*l[1] + 2*l[2] + 4) >> 3) as u8;
 393     dst[2 + 0 * stride] = pix;
 394     dst[0 + 1 * stride] = pix;
 395     let pix = ((t[4] + 2*t[5] + t[6] + l[1] + 2*l[2] + l[3] + 4) >> 3) as u8;
 396     dst[3 + 0 * stride] = pix;
 397     dst[1 + 1 * stride] = pix;
 398     let pix = ((t[5] + 2*t[6] + t[7] + 2*l[2] + 2*l[3] + 4) >> 3) as u8;
 399     dst[2 + 1 * stride] = pix;
 400     dst[0 + 2 * stride] = pix;
 401     let pix = ((t[6] + 3*t[7] + l[2] + 3*l[3] + 4) >> 3) as u8;
 402     dst[3 + 1 * stride] = pix;
 403     dst[1 + 2 * stride] = pix;
 404     let pix = ((l[3] + 2*l[4] + l[5] + 2) >> 2) as u8;
 405     dst[3 + 2 * stride] = pix;
 406     dst[1 + 3 * stride] = pix;
 407     let pix = ((t[6] + t[7] + l[3] + l[4] + 2) >> 2) as u8;
 408     dst[0 + 3 * stride] = pix;
 409     dst[2 + 2 * stride] = pix;
 410     dst[2 + 3 * stride] = ((l[4] + l[5] + 1) >> 1) as u8;
 411     dst[3 + 3 * stride] = ((l[4] + 2*l[5] + l[6] + 2) >> 2) as u8;
 412 }
 413 fn ipred_4x4_hor_up_nodown(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]) {
 414     let mut t: [u16; 8] = [0; 8];
 415     let mut l: [u16; 4] = [0; 4];
 416     load_top(&mut t, buf, idx, stride, 4);
 417     for i in 0..4 { t[i + 4] = tr[i] as u16; }
 418     load_left(&mut l, buf, idx, stride, 4);
 419     let dst = &mut buf[idx..];
 420
 421     dst[0 + 0 * stride] = ((t[1] + 2*t[2] + t[3] + 2*l[0] + 2*l[1] + 4) >> 3) as u8;
 422     dst[1 + 0 * stride] = ((t[2] + 2*t[3] + t[4] + l[0] + 2*l[1] + l[2] + 4) >> 3) as u8;
 423     let pix = ((t[3] + 2*t[4] + t[5] + 2*l[1] + 2*l[2] + 4) >> 3) as u8;
 424     dst[2 + 0 * stride] = pix;
 425     dst[0 + 1 * stride] = pix;
 426     let pix = ((t[4] + 2*t[5] + t[6] + l[1] + 2*l[2] + l[3] + 4) >> 3) as u8;
 427     dst[3 + 0 * stride] = pix;
 428     dst[1 + 1 * stride] = pix;
 429     let pix = ((t[5] + 2*t[6] + t[7] + 2*l[2] + 2*l[3] + 4) >> 3) as u8;
 430     dst[2 + 1 * stride] = pix;
 431     dst[0 + 2 * stride] = pix;
 432     let pix = ((t[6] + 3*t[7] + l[2] + 3*l[3] + 4) >> 3) as u8;
 433     dst[3 + 1 * stride] = pix;
 434     dst[1 + 2 * stride] = pix;
 435     dst[3 + 2 * stride] = l[3] as u8;
 436     dst[1 + 3 * stride] = l[3] as u8;
 437     let pix = ((t[6] + t[7] + 2*l[3] + 2) >> 2) as u8;
 438     dst[0 + 3 * stride] = pix;
 439     dst[2 + 2 * stride] = pix;
 440     dst[2 + 3 * stride] = l[3] as u8;
 441     dst[3 + 3 * stride] = l[3] as u8;
 442 }
 443 fn ipred_4x4_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 444     ipred_dc(buf, idx, stride, 4, 3);
 445 }
 446 fn ipred_4x4_left_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 447     ipred_left_dc(buf, idx, stride, 4, 2);
 448 }
 449 fn ipred_4x4_top_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 450     ipred_top_dc(buf, idx, stride, 4, 2);
 451 }
 452 fn ipred_4x4_dc128(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
 453     ipred_dc128(buf, idx, stride, 4);
 454 }
 455
 456 fn ipred_8x8_ver(buf: &mut [u8], idx: usize, stride: usize) {
 457     ipred_ver(buf, idx, stride, 8);
 458 }
 459 fn ipred_8x8_hor(buf: &mut [u8], idx: usize, stride: usize) {
 460     ipred_hor(buf, idx, stride, 8);
 461 }
 462 fn ipred_8x8_dc(buf: &mut [u8], idx: usize, stride: usize) {
 463     ipred_dc(buf, idx, stride, 8, 4);
 464 }
 465 fn ipred_8x8_left_dc(buf: &mut [u8], idx: usize, stride: usize) {
 466     ipred_left_dc(buf, idx, stride, 8, 3);
 467 }
 468 fn ipred_8x8_top_dc(buf: &mut [u8], idx: usize, stride: usize) {
 469     ipred_top_dc(buf, idx, stride, 8, 3);
 470 }
 471 fn ipred_8x8_dc128(buf: &mut [u8], idx: usize, stride: usize) {
 472     ipred_dc128(buf, idx, stride, 8);
 473 }
 474 fn ipred_8x8_plane(_buf: &mut [u8], _idx: usize, _stride: usize) {
 475     unreachable!();
 476 /*    let mut h: i16 = 0;
 477     let mut v: i16 = 0;
 478     for i in 0..4 {
 479         let i1 = (i + 1) as i16;
 480         h += i1 * ((buf[idx + (4 + i)          - stride] as i16) - (buf[idx + (2 - i)          - stride] as i16));
 481         v += i1 * ((buf[idx + (4 + i) * stride - 1]      as i16) - (buf[idx + (2 - i) * stride - 1] as i16));
 482     }
 483     let a = 16 * ((buf[idx - 1 + 7 * stride] as i16) + (buf[idx + 7 - stride] as i16));
 484     let b = (17 * h + 16) >> 5;
 485     let c = (17 * v + 16) >> 5;
 486     for y in 0..8 {
 487         let j3 = (y as i16) - 3;
 488         for x in 0..8 {
 489             let i3 = (x as i16) - 3;
 490             buf[idx + x] = clip8((a + b * i3 + c * j3 + 16) >> 5);
 491         }
 492         idx += stride;
 493     }*/
 494 }
 495
 496 fn ipred_16x16_ver(buf: &mut [u8], idx: usize, stride: usize) {
 497     ipred_ver(buf, idx, stride, 16);
 498 }
 499 fn ipred_16x16_hor(buf: &mut [u8], idx: usize, stride: usize) {
 500     ipred_hor(buf, idx, stride, 16);
 501 }
 502 fn ipred_16x16_dc(buf: &mut [u8], idx: usize, stride: usize) {
 503     ipred_dc(buf, idx, stride, 16, 5);
 504 }
 505 fn ipred_16x16_left_dc(buf: &mut [u8], idx: usize, stride: usize) {
 506     ipred_left_dc(buf, idx, stride, 16, 4);
 507 }
 508 fn ipred_16x16_top_dc(buf: &mut [u8], idx: usize, stride: usize) {
 509     ipred_top_dc(buf, idx, stride, 16, 4);
 510 }
 511 fn ipred_16x16_dc128(buf: &mut [u8], idx: usize, stride: usize) {
 512     ipred_dc128(buf, idx, stride, 16);
 513 }
 514 fn ipred_16x16_plane(buf: &mut [u8], mut idx: usize, stride: usize) {
 515     let     idx0 = idx + 7 - stride;
 516     let mut idx1 = idx + 8*stride - 1;
 517     let mut idx2 = idx1 - 2*stride;
 518
 519     let mut h = (buf[idx0 + 1] as i16) - (buf[idx0 - 1] as i16);
 520     let mut v = (buf[idx1 + 0] as i16) - (buf[idx2 + 0] as i16);
 521
 522     for k in 2..9 {
 523         idx1 += stride;
 524         idx2 -= stride;
 525         h += (k as i16) * ((buf[idx0 + k] as i16) - (buf[idx0 - k] as i16));
 526         v += (k as i16) * ((buf[idx1 + 0] as i16) - (buf[idx2 + 0] as i16));
 527     }
 528     h = (h + (h >> 2)) >> 4;
 529     v = (v + (v >> 2)) >> 4;
 530
 531     let mut a = 16 * ((buf[idx1 + 0] as i16) + (buf[idx2 + 16] as i16) + 1) - 7 * (v + h);
 532
 533     for _ in 0..16 {
 534         let mut b = a;
 535         a += v;
 536
 537         for x in 0..4 {
 538             buf[idx + x * 4 + 0] = clip8((b      ) >> 5);
 539             buf[idx + x * 4 + 1] = clip8((b +   h) >> 5);
 540             buf[idx + x * 4 + 2] = clip8((b + 2*h) >> 5);
 541             buf[idx + x * 4 + 3] = clip8((b + 3*h) >> 5);
 542             b += h * 4;
 543         }
 544         idx += stride;
 545     }
 546 }
 547
 548 const IPRED_FUNCS4X4: [fn(buf: &mut [u8], idx: usize, stride: usize, tr: &[u8]); 15] = [
 549     ipred_4x4_ver, ipred_4x4_hor, ipred_4x4_dc,
 550     ipred_4x4_diag_down_left, ipred_4x4_diag_down_right,
 551     ipred_4x4_ver_right, ipred_4x4_hor_down, ipred_4x4_ver_left, ipred_4x4_hor_up,
 552     ipred_4x4_left_dc, ipred_4x4_top_dc, ipred_4x4_dc128,
 553     ipred_4x4_diag_down_left_nodown, ipred_4x4_hor_up_nodown, ipred_4x4_ver_left_nodown
 554 ];
 555
 556 const IPRED_FUNCS8X8: [fn(buf: &mut [u8], idx: usize, stride: usize); 7] = [
 557     ipred_8x8_dc, ipred_8x8_hor, ipred_8x8_ver, ipred_8x8_plane,
 558     ipred_8x8_left_dc, ipred_8x8_top_dc, ipred_8x8_dc128
 559 ];
 560
 561 const IPRED_FUNCS16X16: [fn(buf: &mut [u8], idx: usize, stride: usize); 7] = [
 562     ipred_16x16_dc, ipred_16x16_hor, ipred_16x16_ver, ipred_16x16_plane,
 563     ipred_16x16_left_dc, ipred_16x16_top_dc, ipred_16x16_dc128
 564 ];