]>
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 | ||
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 | ||
61d3e294 | 39 | #[allow(clippy::erasing_op)] |
47527732 KS |
40 | fn 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 | ||
53 | fn 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)] | |
60 | fn 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 |
66 | impl 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 | ||
148 | fn 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 | } | |
154 | fn 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 | } | |
161 | fn 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 | } | |
167 | fn 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 | } | |
178 | fn 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 | } | |
188 | fn 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 | ||
199 | fn 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 | } | |
202 | fn 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 | ||
206 | fn ipred_4x4_ver(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) { | |
207 | ipred_ver(buf, idx, stride, 4); | |
208 | } | |
209 | fn ipred_4x4_hor(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) { | |
210 | ipred_hor(buf, idx, stride, 4); | |
211 | } | |
212 | fn 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 | } | |
242 | fn 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 | } | |
272 | fn 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 | } | |
289 | fn 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 | } | |
317 | fn 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 | ||
350 | fn 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 | } | |
353 | fn 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 | } | |
356 | fn 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 | } | |
384 | fn 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 | } | |
415 | fn 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 | } | |
445 | fn ipred_4x4_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) { | |
446 | ipred_dc(buf, idx, stride, 4, 3); | |
447 | } | |
448 | fn ipred_4x4_left_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) { | |
449 | ipred_left_dc(buf, idx, stride, 4, 2); | |
450 | } | |
451 | fn ipred_4x4_top_dc(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) { | |
452 | ipred_top_dc(buf, idx, stride, 4, 2); | |
453 | } | |
454 | fn ipred_4x4_dc128(buf: &mut [u8], idx: usize, stride: usize, _tr: &[u8]) { | |
455 | ipred_dc128(buf, idx, stride, 4); | |
456 | } | |
457 | ||
458 | fn ipred_8x8_ver(buf: &mut [u8], idx: usize, stride: usize) { | |
459 | ipred_ver(buf, idx, stride, 8); | |
460 | } | |
461 | fn ipred_8x8_hor(buf: &mut [u8], idx: usize, stride: usize) { | |
462 | ipred_hor(buf, idx, stride, 8); | |
463 | } | |
464 | fn ipred_8x8_dc(buf: &mut [u8], idx: usize, stride: usize) { | |
465 | ipred_dc(buf, idx, stride, 8, 4); | |
466 | } | |
467 | fn ipred_8x8_left_dc(buf: &mut [u8], idx: usize, stride: usize) { | |
468 | ipred_left_dc(buf, idx, stride, 8, 3); | |
469 | } | |
470 | fn ipred_8x8_top_dc(buf: &mut [u8], idx: usize, stride: usize) { | |
471 | ipred_top_dc(buf, idx, stride, 8, 3); | |
472 | } | |
473 | fn ipred_8x8_dc128(buf: &mut [u8], idx: usize, stride: usize) { | |
474 | ipred_dc128(buf, idx, stride, 8); | |
475 | } | |
476 | fn 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 | ||
498 | fn ipred_16x16_ver(buf: &mut [u8], idx: usize, stride: usize) { | |
499 | ipred_ver(buf, idx, stride, 16); | |
500 | } | |
501 | fn ipred_16x16_hor(buf: &mut [u8], idx: usize, stride: usize) { | |
502 | ipred_hor(buf, idx, stride, 16); | |
503 | } | |
504 | fn ipred_16x16_dc(buf: &mut [u8], idx: usize, stride: usize) { | |
505 | ipred_dc(buf, idx, stride, 16, 5); | |
506 | } | |
507 | fn ipred_16x16_left_dc(buf: &mut [u8], idx: usize, stride: usize) { | |
508 | ipred_left_dc(buf, idx, stride, 16, 4); | |
509 | } | |
510 | fn ipred_16x16_top_dc(buf: &mut [u8], idx: usize, stride: usize) { | |
511 | ipred_top_dc(buf, idx, stride, 16, 4); | |
512 | } | |
513 | fn ipred_16x16_dc128(buf: &mut [u8], idx: usize, stride: usize) { | |
514 | ipred_dc128(buf, idx, stride, 16); | |
515 | } | |
516 | fn 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 | ||
550 | const 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 | ||
558 | const 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 | ||
563 | const 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 | ]; |