Debian Codegraph @

.cargo/vendor/zune-jpeg/src/idct/scalar.rs

raw
1 /*
2 * Copyright (c) 2023.
3 *
4 * This software is free software;
5 *
6 * You can redistribute it or modify it under terms of the MIT, Apache License or Zlib license
7 */
8
9 //! Platform independent IDCT algorithm
10 //!
11 //! Not as fast as AVX one.
12
13 const SCALE_BITS: i32 = 512 + 65536 + (128 << 17);
14
15 #[inline(always)]
16 fn wa(a: i32, b: i32) -> i32 {
17 a.wrapping_add(b)
18 }
19
20 #[inline(always)]
21 fn ws(a: i32, b: i32) -> i32 {
22 a.wrapping_sub(b)
23 }
24
25 #[inline(always)]
26 fn wm(a: i32, b: i32) -> i32 {
27 a.wrapping_mul(b)
28 }
29
30 #[inline]
31 pub fn idct_int_1x1(in_vector: &mut [i32; 64], mut out_vector: &mut [i16], stride: usize) {
32 let coeff = ((wa(wa(in_vector[0], 4), 1024) >> 3).clamp(0, 255)) as i16;
33
34 out_vector[..8].fill(coeff);
35 for _ in 0..7 {
36 out_vector = &mut out_vector[stride..];
37 out_vector[..8].fill(coeff);
38 }
39 }
40
41 #[allow(unused_assignments)]
42 #[allow(
43 clippy::too_many_lines,
44 clippy::op_ref,
45 clippy::cast_possible_truncation
46 )]
47 pub fn idct_int(in_vector: &mut [i32; 64], out_vector: &mut [i16], stride: usize) {
48 let mut pos = 0;
49 let mut i = 0;
50
51 if &in_vector[1..] == &[0_i32; 63] {
52 return idct_int_1x1(in_vector, out_vector, stride);
53 }
54
55 // vertical pass
56 for ptr in 0..8 {
57 let p2 = in_vector[ptr + 16];
58 let p3 = in_vector[ptr + 48];
59
60 let p1 = wm(wa(p2, p3), 2217);
61
62 let t2 = wa(p1, wm(p3, -7567));
63 let t3 = wa(p1, wm(p2, 3135));
64
65 let p2 = in_vector[ptr];
66 let p3 = in_vector[32 + ptr];
67
68 let t0 = fsh(wa(p2, p3));
69 let t1 = fsh(ws(p2, p3));
70
71 let x0 = wa(wa(t0, t3), 512);
72 let x3 = wa(ws(t0, t3), 512);
73 let x1 = wa(wa(t1, t2), 512);
74 let x2 = wa(ws(t1, t2), 512);
75
76 let mut t0 = in_vector[ptr + 56];
77 let mut t1 = in_vector[ptr + 40];
78 let mut t2 = in_vector[ptr + 24];
79 let mut t3 = in_vector[ptr + 8];
80
81 let p3 = wa(t0, t2);
82 let p4 = wa(t1, t3);
83 let p1 = wa(t0, t3);
84 let p2 = wa(t1, t2);
85 let p5 = wm(wa(p3, p4), 4816);
86
87 t0 = wm(t0, 1223);
88 t1 = wm(t1, 8410);
89 t2 = wm(t2, 12586);
90 t3 = wm(t3, 6149);
91
92 let p1 = wa(p5, wm(p1, -3685));
93 let p2 = wa(p5, wm(p2, -10497));
94 let p3 = wm(p3, -8034);
95 let p4 = wm(p4, -1597);
96
97 t3 = wa(t3, wa(p1, p4));
98 t2 = wa(t2, wa(p2, p3));
99 t1 = wa(t1, wa(p2, p4));
100 t0 = wa(t0, wa(p1, p3));
101
102 in_vector[ptr] = ws(wa(x0, t3), 0) >> 10;
103 in_vector[ptr + 8] = ws(wa(x1, t2), 0) >> 10;
104 in_vector[ptr + 16] = ws(wa(x2, t1), 0) >> 10;
105 in_vector[ptr + 24] = ws(wa(x3, t0), 0) >> 10;
106 in_vector[ptr + 32] = ws(ws(x3, t0), 0) >> 10;
107 in_vector[ptr + 40] = ws(ws(x2, t1), 0) >> 10;
108 in_vector[ptr + 48] = ws(ws(x1, t2), 0) >> 10;
109 in_vector[ptr + 56] = ws(ws(x0, t3), 0) >> 10;
110 }
111
112 // horizontal pass
113 while i < 64 {
114 let p2 = in_vector[i + 2];
115 let p3 = in_vector[i + 6];
116
117 let p1 = wm(wa(p2, p3), 2217);
118 let t2 = wa(p1, wm(p3, -7567));
119 let t3 = wa(p1, wm(p2, 3135));
120
121 let p2 = in_vector[i];
122 let p3 = in_vector[i + 4];
123
124 let t0 = fsh(wa(p2, p3));
125 let t1 = fsh(ws(p2, p3));
126
127 let x0 = wa(wa(t0, t3), SCALE_BITS);
128 let x3 = wa(ws(t0, t3), SCALE_BITS);
129 let x1 = wa(wa(t1, t2), SCALE_BITS);
130 let x2 = wa(ws(t1, t2), SCALE_BITS);
131
132 let mut t0 = in_vector[i + 7];
133 let mut t1 = in_vector[i + 5];
134 let mut t2 = in_vector[i + 3];
135 let mut t3 = in_vector[i + 1];
136
137 let p3 = wa(t0, t2);
138 let p4 = wa(t1, t3);
139 let p1 = wa(t0, t3);
140 let p2 = wa(t1, t2);
141 let p5 = wm(wa(p3, p4), f2f(1.175875602));
142
143 t0 = wm(t0, 1223);
144 t1 = wm(t1, 8410);
145 t2 = wm(t2, 12586);
146 t3 = wm(t3, 6149);
147
148 let p1 = wa(p5, wm(p1, -3685));
149 let p2 = wa(p5, wm(p2, -10497));
150 let p3 = wm(p3, -8034);
151 let p4 = wm(p4, -1597);
152
153 t3 = wa(t3, wa(p1, p4));
154 t2 = wa(t2, wa(p2, p3));
155 t1 = wa(t1, wa(p2, p4));
156 t0 = wa(t0, wa(p1, p3));
157
158 let out: &mut [i16; 8] = out_vector
159 .get_mut(pos..pos + 8)
160 .unwrap()
161 .try_into()
162 .unwrap();
163
164 out[0] = clamp(wa(x0, t3) >> 17);
165 out[1] = clamp(wa(x1, t2) >> 17);
166 out[2] = clamp(wa(x2, t1) >> 17);
167 out[3] = clamp(wa(x3, t0) >> 17);
168 out[4] = clamp(ws(x3, t0) >> 17);
169 out[5] = clamp(ws(x2, t1) >> 17);
170 out[6] = clamp(ws(x1, t2) >> 17);
171 out[7] = clamp(ws(x0, t3) >> 17);
172
173 i += 8;
174 pos += stride;
175 }
176 }
177
178 #[inline]
179 #[allow(clippy::cast_possible_truncation)]
180 /// Multiply a number by 4096
181 fn f2f(x: f32) -> i32 {
182 (x * 4096.0 + 0.5) as i32
183 }
184
185 #[inline]
186 /// Multiply a number by 4096
187 fn fsh(x: i32) -> i32 {
188 x << 12
189 }
190
191 /// Clamp values between 0 and 255
192 #[inline]
193 #[allow(clippy::cast_possible_truncation)]
194 fn clamp(a: i32) -> i16 {
195 a.clamp(0, 255) as i16
196 }
197
198 /// IDCT assuming only the upper 4x4 is filled.
199 pub fn idct4x4(in_vector: &mut [i32; 64], out_vector: &mut [i16], stride: usize) {
200 let mut pos = 0;
201
202 // vertical pass
203 for ptr in 0..4 {
204 let i0 = wa(fsh(in_vector[ptr]), 512);
205 let i2 = in_vector[ptr + 16];
206
207 let p1 = wm(i2, 2217);
208 let p3 = wm(i2, 5352);
209
210 let x0 = wa(i0, p3);
211 let x1 = wa(i0, p1);
212 let x2 = ws(i0, p1);
213 let x3 = ws(i0, p3);
214
215 // odd part
216 let i4 = in_vector[ptr + 24];
217 let i3 = in_vector[ptr + 8];
218
219 let p5 = wm(wa(i4, i3), 4816);
220
221 let p1 = wa(p5, wm(i3, -3685));
222 let p2 = wa(p5, wm(i4, -10497));
223
224 let t3 = wa(p5, wm(i3, 867));
225 let t2 = wa(p5, wm(i4, -5945));
226
227 let t1 = wa(p2, wm(i3, -1597));
228 let t0 = wa(p1, wm(i4, -8034));
229
230 in_vector[ptr] = wa(x0, t3) >> 10;
231 in_vector[ptr + 8] = wa(x1, t2) >> 10;
232 in_vector[ptr + 16] = wa(x2, t1) >> 10;
233 in_vector[ptr + 24] = wa(x3, t0) >> 10;
234 in_vector[ptr + 32] = ws(x3, t0) >> 10;
235 in_vector[ptr + 40] = ws(x2, t1) >> 10;
236 in_vector[ptr + 48] = ws(x1, t2) >> 10;
237 in_vector[ptr + 56] = ws(x0, t3) >> 10;
238 }
239
240 // horizontal pass
241 for i in (0..8).map(|i| 8 * i) {
242 let i2 = in_vector[i + 2];
243 let i0 = in_vector[i];
244
245 let t0 = wa(fsh(i0), SCALE_BITS);
246 let t2 = wm(i2, 2217);
247 let t3 = wm(i2, 5352);
248
249 let x0 = wa(t0, t3);
250 let x3 = ws(t0, t3);
251 let x1 = wa(t0, t2);
252 let x2 = ws(t0, t2);
253
254 // odd part
255 let i3 = in_vector[i + 3];
256 let i1 = in_vector[i + 1];
257
258 let p5 = wm(wa(i3, i1), f2f(1.175875602));
259
260 let p1 = wa(p5, wm(i1, -3685));
261 let p2 = wa(p5, wm(i3, -10497));
262
263 let t3 = wa(p5, wm(i1, 867));
264 let t2 = wa(p5, wm(i3, -5945));
265
266 let t1 = wa(p2, wm(i1, -1597));
267 let t0 = wa(p1, wm(i3, -8034));
268
269 let out: &mut [i16; 8] = out_vector
270 .get_mut(pos..pos + 8)
271 .unwrap()
272 .try_into()
273 .unwrap();
274
275 out.copy_from_slice(&[
276 clamp(wa(x0, t3) >> 17),
277 clamp(wa(x1, t2) >> 17),
278 clamp(wa(x2, t1) >> 17),
279 clamp(wa(x3, t0) >> 17),
280 clamp(ws(x3, t0) >> 17),
281 clamp(ws(x2, t1) >> 17),
282 clamp(ws(x1, t2) >> 17),
283 clamp(ws(x0, t3) >> 17),
284 ]);
285
286 pos += stride;
287 }
288
289 in_vector[32..36].fill(0);
290 in_vector[40..44].fill(0);
291 in_vector[48..52].fill(0);
292 in_vector[56..60].fill(0);
293 }