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