2 #[derive(Debug,Clone,Copy)]
22 #[derive(Debug,Clone,Copy)]
23 pub enum PredType8x8 {
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],
39 fn row_transform(src: &[i16], dst: &mut [i32]) {
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;
52 fn clip8(a: i16) -> u8 {
54 else if a > 255 { 255 }
59 fn mclip8(a: i32) -> u8 {
60 if (a as u32) > 255 { !(a >> 16) as u8 }
65 pub fn new() -> Self {
67 ipred4x4: IPRED_FUNCS4X4,
68 ipred8x8: IPRED_FUNCS8X8,
69 ipred16x16: IPRED_FUNCS16X16,
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));
84 pub fn transform(&self, coeffs: &mut [i16]) {
85 let mut tmp: [i32; 16] = [0; 16];
86 row_transform(coeffs, &mut tmp);
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;
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; }
102 pub fn transform16(&self, coeffs: &mut [i16]) {
103 let mut tmp: [i32; 16] = [0; 16];
104 row_transform(coeffs, &mut tmp);
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];
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;
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; }
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,
126 dst[didx + x] = (((((dst[didx + x] as u32) * ratio1) >> 9)
127 + (((src[sidx + x] as u32) * ratio2) >> 9) + 0x10) >> 5) as u8;
133 pub fn avg(&self, dst: &mut [u8], mut didx: usize, dstride: usize,
134 src: &[u8], mut sidx: usize, sstride: usize,
138 dst[didx + x] = (((dst[didx + x] as u16) + (src[sidx + x] as u16) + 1) >> 1) as u8;
146 fn ipred_dc128(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize) {
148 for x in 0..bsize { buf[idx + x] = 128; }
152 fn ipred_ver(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize) {
153 let oidx = idx - stride;
155 for x in 0..bsize { buf[idx + x] = buf[oidx + x]; }
159 fn ipred_hor(buf: &mut [u8], mut idx: usize, stride: usize, bsize: usize) {
161 for x in 0..bsize { buf[idx + x] = buf[idx - 1]; }
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;
172 for x in 0..bsize { buf[idx + x] = dc; }
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;
182 for x in 0..bsize { buf[idx + x] = dc; }
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;
192 for x in 0..bsize { buf[idx + x] = dc; }
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; }
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; }
204 fn ipred_4x4_ver(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
205 ipred_ver(buf, idx, stride, 4);
207 fn ipred_4x4_hor(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
208 ipred_hor(buf, idx, stride, 4);
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..];
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;
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..];
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;
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..];
279 dst[i + j * stride] = ((l[j - i - 1] + 2 * l[j - i] + l[j - i + 1] + 2) >> 2) as u8;
281 dst[j + j * stride] = ((l[1] + 2 * l[0] + t[1] + 2) >> 2) as u8;
283 dst[i + j * stride] = ((t[i - j - 1] + 2 * t[i - j] + t[i - j + 1] + 2) >> 2) as u8;
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..];
296 let zvr = ((2 * i) as i8) - (j as i8);
300 pix = (t[i - (j >> 1)] + t[i - (j >> 1) + 1] + 1) >> 1;
302 pix = (t[i - (j >> 1) - 1] + 2 * t[i - (j >> 1)] + t[i - (j >> 1) + 1] + 2) >> 2;
306 pix = (l[1] + 2 * l[0] + t[1] + 2) >> 2;
308 pix = (l[j] + 2 * l[j - 1] + l[j - 2] + 2) >> 2;
311 dst[i + j * stride] = pix as u8;
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..];
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;
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);
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);
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..];
363 let zhd = ((2 * j) as i8) - (i as i8);
367 pix = (l[j - (i >> 1)] + l[j - (i >> 1) + 1] + 1) >> 1;
369 pix = (l[j - (i >> 1) - 1] + 2 * l[j - (i >> 1)] + l[j - (i >> 1) + 1] + 2) >> 2;
373 pix = (l[1] + 2 * l[0] + t[1] + 2) >> 2;
375 pix = (t[i - 2] + 2 * t[i - 1] + t[i] + 2) >> 2;
378 dst[i + j * stride] = pix as u8;
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..];
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;
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..];
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;
443 fn ipred_4x4_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
444 ipred_dc(buf, idx, stride, 4, 3);
446 fn ipred_4x4_left_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
447 ipred_left_dc(buf, idx, stride, 4, 2);
449 fn ipred_4x4_top_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
450 ipred_top_dc(buf, idx, stride, 4, 2);
452 fn ipred_4x4_dc128(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) {
453 ipred_dc128(buf, idx, stride, 4);
456 fn ipred_8x8_ver(buf: &mut [u8], idx: usize, stride: usize) {
457 ipred_ver(buf, idx, stride, 8);
459 fn ipred_8x8_hor(buf: &mut [u8], idx: usize, stride: usize) {
460 ipred_hor(buf, idx, stride, 8);
462 fn ipred_8x8_dc(buf: &mut [u8], idx: usize, stride: usize) {
463 ipred_dc(buf, idx, stride, 8, 4);
465 fn ipred_8x8_left_dc(buf: &mut [u8], idx: usize, stride: usize) {
466 ipred_left_dc(buf, idx, stride, 8, 3);
468 fn ipred_8x8_top_dc(buf: &mut [u8], idx: usize, stride: usize) {
469 ipred_top_dc(buf, idx, stride, 8, 3);
471 fn ipred_8x8_dc128(buf: &mut [u8], idx: usize, stride: usize) {
472 ipred_dc128(buf, idx, stride, 8);
474 fn ipred_8x8_plane(_buf: &mut [u8], _idx: usize, _stride: usize) {
476 /* let mut h: i16 = 0;
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));
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;
487 let j3 = (y as i16) - 3;
489 let i3 = (x as i16) - 3;
490 buf[idx + x] = clip8((a + b * i3 + c * j3 + 16) >> 5);
496 fn ipred_16x16_ver(buf: &mut [u8], idx: usize, stride: usize) {
497 ipred_ver(buf, idx, stride, 16);
499 fn ipred_16x16_hor(buf: &mut [u8], idx: usize, stride: usize) {
500 ipred_hor(buf, idx, stride, 16);
502 fn ipred_16x16_dc(buf: &mut [u8], idx: usize, stride: usize) {
503 ipred_dc(buf, idx, stride, 16, 5);
505 fn ipred_16x16_left_dc(buf: &mut [u8], idx: usize, stride: usize) {
506 ipred_left_dc(buf, idx, stride, 16, 4);
508 fn ipred_16x16_top_dc(buf: &mut [u8], idx: usize, stride: usize) {
509 ipred_top_dc(buf, idx, stride, 16, 4);
511 fn ipred_16x16_dc128(buf: &mut [u8], idx: usize, stride: usize) {
512 ipred_dc128(buf, idx, stride, 16);
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;
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);
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));
528 h = (h + (h >> 2)) >> 4;
529 v = (v + (v >> 2)) >> 4;
531 let mut a = 16 * ((buf[idx1 + 0] as i16) + (buf[idx2 + 16] as i16) + 1) - 7 * (v + h);
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);
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
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
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