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