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