Line | Count | Source |
1 | | /* |
2 | | * Copyright © 2018-2019, VideoLAN and dav1d authors |
3 | | * Copyright © 2018-2019, Two Orioles, LLC |
4 | | * All rights reserved. |
5 | | * |
6 | | * Redistribution and use in source and binary forms, with or without |
7 | | * modification, are permitted provided that the following conditions are met: |
8 | | * |
9 | | * 1. Redistributions of source code must retain the above copyright notice, this |
10 | | * list of conditions and the following disclaimer. |
11 | | * |
12 | | * 2. Redistributions in binary form must reproduce the above copyright notice, |
13 | | * this list of conditions and the following disclaimer in the documentation |
14 | | * and/or other materials provided with the distribution. |
15 | | * |
16 | | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
17 | | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
18 | | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
19 | | * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR |
20 | | * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
21 | | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
22 | | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
23 | | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
24 | | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
25 | | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
26 | | */ |
27 | | |
28 | | #include "config.h" |
29 | | |
30 | | #include <stddef.h> |
31 | | #include <stdint.h> |
32 | | |
33 | | #include "common/intops.h" |
34 | | |
35 | | #include "src/itx_1d.h" |
36 | | |
37 | 199M | #define CLIP(a) iclip(a, min, max) |
38 | | |
39 | | /* |
40 | | * In some places, we use the pattern like this: |
41 | | * t2 = ((in1 * 1567 - in3 * (3784 - 4096) + 2048) >> 12) - in3; |
42 | | * even though the reference code might use something like: |
43 | | * t2 = (in1 * 1567 - in3 * 3784 + 2048) >> 12; |
44 | | * |
45 | | * The reason for this is that for 12 bits/component bitstreams (corrupt/ |
46 | | * invalid ones, but they are codable nonetheless), each coefficient or |
47 | | * input can be 19(+sign) bits, and therefore if the combination of the |
48 | | * two multipliers (each 12 bits) is >= 4096, the result of the add/sub |
49 | | * after the pair of multiplies will exceed the 31+sign bit range. Signed |
50 | | * integer overflows are UB in C, and we'd like to prevent that. |
51 | | * |
52 | | * To workaround this, we invert one of the two coefficients (or, if both are |
53 | | * multiples of 2, we reduce their magnitude by one bit). It should be noted |
54 | | * that SIMD implementations do not have to follow this exact behaviour. The |
55 | | * AV1 spec clearly states that the result of the multiply/add pairs should |
56 | | * fit in 31+sign bit intermediates, and that streams violating this convention |
57 | | * are not AV1-compliant. So, as long as we don't trigger UB (which some people |
58 | | * would consider a security vulnerability), we're fine. So, SIMD can simply |
59 | | * use the faster implementation, even if that might in some cases result in |
60 | | * integer overflows, since these are not considered valid AV1 anyway, and in |
61 | | * e.g. x86 assembly, integer overflows are not considered UB, but they merely |
62 | | * wrap around. |
63 | | */ |
64 | | |
65 | | static NOINLINE void |
66 | | inv_dct4_1d_internal_c(int32_t *const c, const ptrdiff_t stride, |
67 | | const int min, const int max, const int tx64) |
68 | 1.58M | { |
69 | 1.58M | assert(stride > 0); |
70 | 1.58M | const int in0 = c[0 * stride], in1 = c[1 * stride]; |
71 | | |
72 | 1.58M | int t0, t1, t2, t3; |
73 | 1.58M | if (tx64) { |
74 | 300k | t0 = t1 = (in0 * 181 + 128) >> 8; |
75 | 300k | t2 = (in1 * 1567 + 2048) >> 12; |
76 | 300k | t3 = (in1 * 3784 + 2048) >> 12; |
77 | 1.28M | } else { |
78 | 1.28M | const int in2 = c[2 * stride], in3 = c[3 * stride]; |
79 | | |
80 | 1.28M | t0 = ((in0 + in2) * 181 + 128) >> 8; |
81 | 1.28M | t1 = ((in0 - in2) * 181 + 128) >> 8; |
82 | 1.28M | t2 = ((in1 * 1567 - in3 * (3784 - 4096) + 2048) >> 12) - in3; |
83 | 1.28M | t3 = ((in1 * (3784 - 4096) + in3 * 1567 + 2048) >> 12) + in1; |
84 | 1.28M | } |
85 | | |
86 | 1.58M | c[0 * stride] = CLIP(t0 + t3); |
87 | 1.58M | c[1 * stride] = CLIP(t1 + t2); |
88 | 1.58M | c[2 * stride] = CLIP(t1 - t2); |
89 | 1.58M | c[3 * stride] = CLIP(t0 - t3); |
90 | 1.58M | } |
91 | | |
92 | | static void inv_dct4_1d_c(int32_t *const c, const ptrdiff_t stride, |
93 | | const int min, const int max) |
94 | 106k | { |
95 | 106k | inv_dct4_1d_internal_c(c, stride, min, max, 0); |
96 | 106k | } |
97 | | |
98 | | static NOINLINE void |
99 | | inv_dct8_1d_internal_c(int32_t *const c, const ptrdiff_t stride, |
100 | | const int min, const int max, const int tx64) |
101 | 1.48M | { |
102 | 1.48M | assert(stride > 0); |
103 | 1.48M | inv_dct4_1d_internal_c(c, stride << 1, min, max, tx64); |
104 | | |
105 | 1.48M | const int in1 = c[1 * stride], in3 = c[3 * stride]; |
106 | | |
107 | 1.48M | int t4a, t5a, t6a, t7a; |
108 | 1.48M | if (tx64) { |
109 | 300k | t4a = (in1 * 799 + 2048) >> 12; |
110 | 300k | t5a = (in3 * -2276 + 2048) >> 12; |
111 | 300k | t6a = (in3 * 3406 + 2048) >> 12; |
112 | 300k | t7a = (in1 * 4017 + 2048) >> 12; |
113 | 1.18M | } else { |
114 | 1.18M | const int in5 = c[5 * stride], in7 = c[7 * stride]; |
115 | | |
116 | 1.18M | t4a = ((in1 * 799 - in7 * (4017 - 4096) + 2048) >> 12) - in7; |
117 | 1.18M | t5a = (in5 * 1703 - in3 * 1138 + 1024) >> 11; |
118 | 1.18M | t6a = (in5 * 1138 + in3 * 1703 + 1024) >> 11; |
119 | 1.18M | t7a = ((in1 * (4017 - 4096) + in7 * 799 + 2048) >> 12) + in1; |
120 | 1.18M | } |
121 | | |
122 | 1.48M | const int t4 = CLIP(t4a + t5a); |
123 | 1.48M | t5a = CLIP(t4a - t5a); |
124 | 1.48M | const int t7 = CLIP(t7a + t6a); |
125 | 1.48M | t6a = CLIP(t7a - t6a); |
126 | | |
127 | 1.48M | const int t5 = ((t6a - t5a) * 181 + 128) >> 8; |
128 | 1.48M | const int t6 = ((t6a + t5a) * 181 + 128) >> 8; |
129 | | |
130 | 1.48M | const int t0 = c[0 * stride]; |
131 | 1.48M | const int t1 = c[2 * stride]; |
132 | 1.48M | const int t2 = c[4 * stride]; |
133 | 1.48M | const int t3 = c[6 * stride]; |
134 | | |
135 | 1.48M | c[0 * stride] = CLIP(t0 + t7); |
136 | 1.48M | c[1 * stride] = CLIP(t1 + t6); |
137 | 1.48M | c[2 * stride] = CLIP(t2 + t5); |
138 | 1.48M | c[3 * stride] = CLIP(t3 + t4); |
139 | 1.48M | c[4 * stride] = CLIP(t3 - t4); |
140 | 1.48M | c[5 * stride] = CLIP(t2 - t5); |
141 | 1.48M | c[6 * stride] = CLIP(t1 - t6); |
142 | 1.48M | c[7 * stride] = CLIP(t0 - t7); |
143 | 1.48M | } |
144 | | |
145 | | static void inv_dct8_1d_c(int32_t *const c, const ptrdiff_t stride, |
146 | | const int min, const int max) |
147 | 268k | { |
148 | 268k | inv_dct8_1d_internal_c(c, stride, min, max, 0); |
149 | 268k | } |
150 | | |
151 | | static NOINLINE void |
152 | | inv_dct16_1d_internal_c(int32_t *const c, const ptrdiff_t stride, |
153 | | const int min, const int max, int tx64) |
154 | 1.21M | { |
155 | 1.21M | assert(stride > 0); |
156 | 1.21M | inv_dct8_1d_internal_c(c, stride << 1, min, max, tx64); |
157 | | |
158 | 1.21M | const int in1 = c[1 * stride], in3 = c[3 * stride]; |
159 | 1.21M | const int in5 = c[5 * stride], in7 = c[7 * stride]; |
160 | | |
161 | 1.21M | int t8a, t9a, t10a, t11a, t12a, t13a, t14a, t15a; |
162 | 1.21M | if (tx64) { |
163 | 300k | t8a = (in1 * 401 + 2048) >> 12; |
164 | 300k | t9a = (in7 * -2598 + 2048) >> 12; |
165 | 300k | t10a = (in5 * 1931 + 2048) >> 12; |
166 | 300k | t11a = (in3 * -1189 + 2048) >> 12; |
167 | 300k | t12a = (in3 * 3920 + 2048) >> 12; |
168 | 300k | t13a = (in5 * 3612 + 2048) >> 12; |
169 | 300k | t14a = (in7 * 3166 + 2048) >> 12; |
170 | 300k | t15a = (in1 * 4076 + 2048) >> 12; |
171 | 912k | } else { |
172 | 912k | const int in9 = c[ 9 * stride], in11 = c[11 * stride]; |
173 | 912k | const int in13 = c[13 * stride], in15 = c[15 * stride]; |
174 | | |
175 | 912k | t8a = ((in1 * 401 - in15 * (4076 - 4096) + 2048) >> 12) - in15; |
176 | 912k | t9a = (in9 * 1583 - in7 * 1299 + 1024) >> 11; |
177 | 912k | t10a = ((in5 * 1931 - in11 * (3612 - 4096) + 2048) >> 12) - in11; |
178 | 912k | t11a = ((in13 * (3920 - 4096) - in3 * 1189 + 2048) >> 12) + in13; |
179 | 912k | t12a = ((in13 * 1189 + in3 * (3920 - 4096) + 2048) >> 12) + in3; |
180 | 912k | t13a = ((in5 * (3612 - 4096) + in11 * 1931 + 2048) >> 12) + in5; |
181 | 912k | t14a = (in9 * 1299 + in7 * 1583 + 1024) >> 11; |
182 | 912k | t15a = ((in1 * (4076 - 4096) + in15 * 401 + 2048) >> 12) + in1; |
183 | 912k | } |
184 | | |
185 | 1.21M | int t8 = CLIP(t8a + t9a); |
186 | 1.21M | int t9 = CLIP(t8a - t9a); |
187 | 1.21M | int t10 = CLIP(t11a - t10a); |
188 | 1.21M | int t11 = CLIP(t11a + t10a); |
189 | 1.21M | int t12 = CLIP(t12a + t13a); |
190 | 1.21M | int t13 = CLIP(t12a - t13a); |
191 | 1.21M | int t14 = CLIP(t15a - t14a); |
192 | 1.21M | int t15 = CLIP(t15a + t14a); |
193 | | |
194 | 1.21M | t9a = (( t14 * 1567 - t9 * (3784 - 4096) + 2048) >> 12) - t9; |
195 | 1.21M | t14a = (( t14 * (3784 - 4096) + t9 * 1567 + 2048) >> 12) + t14; |
196 | 1.21M | t10a = ((-(t13 * (3784 - 4096) + t10 * 1567) + 2048) >> 12) - t13; |
197 | 1.21M | t13a = (( t13 * 1567 - t10 * (3784 - 4096) + 2048) >> 12) - t10; |
198 | | |
199 | 1.21M | t8a = CLIP(t8 + t11); |
200 | 1.21M | t9 = CLIP(t9a + t10a); |
201 | 1.21M | t10 = CLIP(t9a - t10a); |
202 | 1.21M | t11a = CLIP(t8 - t11); |
203 | 1.21M | t12a = CLIP(t15 - t12); |
204 | 1.21M | t13 = CLIP(t14a - t13a); |
205 | 1.21M | t14 = CLIP(t14a + t13a); |
206 | 1.21M | t15a = CLIP(t15 + t12); |
207 | | |
208 | 1.21M | t10a = ((t13 - t10) * 181 + 128) >> 8; |
209 | 1.21M | t13a = ((t13 + t10) * 181 + 128) >> 8; |
210 | 1.21M | t11 = ((t12a - t11a) * 181 + 128) >> 8; |
211 | 1.21M | t12 = ((t12a + t11a) * 181 + 128) >> 8; |
212 | | |
213 | 1.21M | const int t0 = c[ 0 * stride]; |
214 | 1.21M | const int t1 = c[ 2 * stride]; |
215 | 1.21M | const int t2 = c[ 4 * stride]; |
216 | 1.21M | const int t3 = c[ 6 * stride]; |
217 | 1.21M | const int t4 = c[ 8 * stride]; |
218 | 1.21M | const int t5 = c[10 * stride]; |
219 | 1.21M | const int t6 = c[12 * stride]; |
220 | 1.21M | const int t7 = c[14 * stride]; |
221 | | |
222 | 1.21M | c[ 0 * stride] = CLIP(t0 + t15a); |
223 | 1.21M | c[ 1 * stride] = CLIP(t1 + t14); |
224 | 1.21M | c[ 2 * stride] = CLIP(t2 + t13a); |
225 | 1.21M | c[ 3 * stride] = CLIP(t3 + t12); |
226 | 1.21M | c[ 4 * stride] = CLIP(t4 + t11); |
227 | 1.21M | c[ 5 * stride] = CLIP(t5 + t10a); |
228 | 1.21M | c[ 6 * stride] = CLIP(t6 + t9); |
229 | 1.21M | c[ 7 * stride] = CLIP(t7 + t8a); |
230 | 1.21M | c[ 8 * stride] = CLIP(t7 - t8a); |
231 | 1.21M | c[ 9 * stride] = CLIP(t6 - t9); |
232 | 1.21M | c[10 * stride] = CLIP(t5 - t10a); |
233 | 1.21M | c[11 * stride] = CLIP(t4 - t11); |
234 | 1.21M | c[12 * stride] = CLIP(t3 - t12); |
235 | 1.21M | c[13 * stride] = CLIP(t2 - t13a); |
236 | 1.21M | c[14 * stride] = CLIP(t1 - t14); |
237 | 1.21M | c[15 * stride] = CLIP(t0 - t15a); |
238 | 1.21M | } |
239 | | |
240 | | static void inv_dct16_1d_c(int32_t *const c, const ptrdiff_t stride, |
241 | | const int min, const int max) |
242 | 380k | { |
243 | 380k | inv_dct16_1d_internal_c(c, stride, min, max, 0); |
244 | 380k | } |
245 | | |
246 | | static NOINLINE void |
247 | | inv_dct32_1d_internal_c(int32_t *const c, const ptrdiff_t stride, |
248 | | const int min, const int max, const int tx64) |
249 | 833k | { |
250 | 833k | assert(stride > 0); |
251 | 833k | inv_dct16_1d_internal_c(c, stride << 1, min, max, tx64); |
252 | | |
253 | 833k | const int in1 = c[ 1 * stride], in3 = c[ 3 * stride]; |
254 | 833k | const int in5 = c[ 5 * stride], in7 = c[ 7 * stride]; |
255 | 833k | const int in9 = c[ 9 * stride], in11 = c[11 * stride]; |
256 | 833k | const int in13 = c[13 * stride], in15 = c[15 * stride]; |
257 | | |
258 | 833k | int t16a, t17a, t18a, t19a, t20a, t21a, t22a, t23a; |
259 | 833k | int t24a, t25a, t26a, t27a, t28a, t29a, t30a, t31a; |
260 | 833k | if (tx64) { |
261 | 300k | t16a = (in1 * 201 + 2048) >> 12; |
262 | 300k | t17a = (in15 * -2751 + 2048) >> 12; |
263 | 300k | t18a = (in9 * 1751 + 2048) >> 12; |
264 | 300k | t19a = (in7 * -1380 + 2048) >> 12; |
265 | 300k | t20a = (in5 * 995 + 2048) >> 12; |
266 | 300k | t21a = (in11 * -2106 + 2048) >> 12; |
267 | 300k | t22a = (in13 * 2440 + 2048) >> 12; |
268 | 300k | t23a = (in3 * -601 + 2048) >> 12; |
269 | 300k | t24a = (in3 * 4052 + 2048) >> 12; |
270 | 300k | t25a = (in13 * 3290 + 2048) >> 12; |
271 | 300k | t26a = (in11 * 3513 + 2048) >> 12; |
272 | 300k | t27a = (in5 * 3973 + 2048) >> 12; |
273 | 300k | t28a = (in7 * 3857 + 2048) >> 12; |
274 | 300k | t29a = (in9 * 3703 + 2048) >> 12; |
275 | 300k | t30a = (in15 * 3035 + 2048) >> 12; |
276 | 300k | t31a = (in1 * 4091 + 2048) >> 12; |
277 | 532k | } else { |
278 | 532k | const int in17 = c[17 * stride], in19 = c[19 * stride]; |
279 | 532k | const int in21 = c[21 * stride], in23 = c[23 * stride]; |
280 | 532k | const int in25 = c[25 * stride], in27 = c[27 * stride]; |
281 | 532k | const int in29 = c[29 * stride], in31 = c[31 * stride]; |
282 | | |
283 | 532k | t16a = ((in1 * 201 - in31 * (4091 - 4096) + 2048) >> 12) - in31; |
284 | 532k | t17a = ((in17 * (3035 - 4096) - in15 * 2751 + 2048) >> 12) + in17; |
285 | 532k | t18a = ((in9 * 1751 - in23 * (3703 - 4096) + 2048) >> 12) - in23; |
286 | 532k | t19a = ((in25 * (3857 - 4096) - in7 * 1380 + 2048) >> 12) + in25; |
287 | 532k | t20a = ((in5 * 995 - in27 * (3973 - 4096) + 2048) >> 12) - in27; |
288 | 532k | t21a = ((in21 * (3513 - 4096) - in11 * 2106 + 2048) >> 12) + in21; |
289 | 532k | t22a = (in13 * 1220 - in19 * 1645 + 1024) >> 11; |
290 | 532k | t23a = ((in29 * (4052 - 4096) - in3 * 601 + 2048) >> 12) + in29; |
291 | 532k | t24a = ((in29 * 601 + in3 * (4052 - 4096) + 2048) >> 12) + in3; |
292 | 532k | t25a = (in13 * 1645 + in19 * 1220 + 1024) >> 11; |
293 | 532k | t26a = ((in21 * 2106 + in11 * (3513 - 4096) + 2048) >> 12) + in11; |
294 | 532k | t27a = ((in5 * (3973 - 4096) + in27 * 995 + 2048) >> 12) + in5; |
295 | 532k | t28a = ((in25 * 1380 + in7 * (3857 - 4096) + 2048) >> 12) + in7; |
296 | 532k | t29a = ((in9 * (3703 - 4096) + in23 * 1751 + 2048) >> 12) + in9; |
297 | 532k | t30a = ((in17 * 2751 + in15 * (3035 - 4096) + 2048) >> 12) + in15; |
298 | 532k | t31a = ((in1 * (4091 - 4096) + in31 * 201 + 2048) >> 12) + in1; |
299 | 532k | } |
300 | | |
301 | 833k | int t16 = CLIP(t16a + t17a); |
302 | 833k | int t17 = CLIP(t16a - t17a); |
303 | 833k | int t18 = CLIP(t19a - t18a); |
304 | 833k | int t19 = CLIP(t19a + t18a); |
305 | 833k | int t20 = CLIP(t20a + t21a); |
306 | 833k | int t21 = CLIP(t20a - t21a); |
307 | 833k | int t22 = CLIP(t23a - t22a); |
308 | 833k | int t23 = CLIP(t23a + t22a); |
309 | 833k | int t24 = CLIP(t24a + t25a); |
310 | 833k | int t25 = CLIP(t24a - t25a); |
311 | 833k | int t26 = CLIP(t27a - t26a); |
312 | 833k | int t27 = CLIP(t27a + t26a); |
313 | 833k | int t28 = CLIP(t28a + t29a); |
314 | 833k | int t29 = CLIP(t28a - t29a); |
315 | 833k | int t30 = CLIP(t31a - t30a); |
316 | 833k | int t31 = CLIP(t31a + t30a); |
317 | | |
318 | 833k | t17a = (( t30 * 799 - t17 * (4017 - 4096) + 2048) >> 12) - t17; |
319 | 833k | t30a = (( t30 * (4017 - 4096) + t17 * 799 + 2048) >> 12) + t30; |
320 | 833k | t18a = ((-(t29 * (4017 - 4096) + t18 * 799) + 2048) >> 12) - t29; |
321 | 833k | t29a = (( t29 * 799 - t18 * (4017 - 4096) + 2048) >> 12) - t18; |
322 | 833k | t21a = ( t26 * 1703 - t21 * 1138 + 1024) >> 11; |
323 | 833k | t26a = ( t26 * 1138 + t21 * 1703 + 1024) >> 11; |
324 | 833k | t22a = (-(t25 * 1138 + t22 * 1703 ) + 1024) >> 11; |
325 | 833k | t25a = ( t25 * 1703 - t22 * 1138 + 1024) >> 11; |
326 | | |
327 | 833k | t16a = CLIP(t16 + t19); |
328 | 833k | t17 = CLIP(t17a + t18a); |
329 | 833k | t18 = CLIP(t17a - t18a); |
330 | 833k | t19a = CLIP(t16 - t19); |
331 | 833k | t20a = CLIP(t23 - t20); |
332 | 833k | t21 = CLIP(t22a - t21a); |
333 | 833k | t22 = CLIP(t22a + t21a); |
334 | 833k | t23a = CLIP(t23 + t20); |
335 | 833k | t24a = CLIP(t24 + t27); |
336 | 833k | t25 = CLIP(t25a + t26a); |
337 | 833k | t26 = CLIP(t25a - t26a); |
338 | 833k | t27a = CLIP(t24 - t27); |
339 | 833k | t28a = CLIP(t31 - t28); |
340 | 833k | t29 = CLIP(t30a - t29a); |
341 | 833k | t30 = CLIP(t30a + t29a); |
342 | 833k | t31a = CLIP(t31 + t28); |
343 | | |
344 | 833k | t18a = (( t29 * 1567 - t18 * (3784 - 4096) + 2048) >> 12) - t18; |
345 | 833k | t29a = (( t29 * (3784 - 4096) + t18 * 1567 + 2048) >> 12) + t29; |
346 | 833k | t19 = (( t28a * 1567 - t19a * (3784 - 4096) + 2048) >> 12) - t19a; |
347 | 833k | t28 = (( t28a * (3784 - 4096) + t19a * 1567 + 2048) >> 12) + t28a; |
348 | 833k | t20 = ((-(t27a * (3784 - 4096) + t20a * 1567) + 2048) >> 12) - t27a; |
349 | 833k | t27 = (( t27a * 1567 - t20a * (3784 - 4096) + 2048) >> 12) - t20a; |
350 | 833k | t21a = ((-(t26 * (3784 - 4096) + t21 * 1567) + 2048) >> 12) - t26; |
351 | 833k | t26a = (( t26 * 1567 - t21 * (3784 - 4096) + 2048) >> 12) - t21; |
352 | | |
353 | 833k | t16 = CLIP(t16a + t23a); |
354 | 833k | t17a = CLIP(t17 + t22); |
355 | 833k | t18 = CLIP(t18a + t21a); |
356 | 833k | t19a = CLIP(t19 + t20); |
357 | 833k | t20a = CLIP(t19 - t20); |
358 | 833k | t21 = CLIP(t18a - t21a); |
359 | 833k | t22a = CLIP(t17 - t22); |
360 | 833k | t23 = CLIP(t16a - t23a); |
361 | 833k | t24 = CLIP(t31a - t24a); |
362 | 833k | t25a = CLIP(t30 - t25); |
363 | 833k | t26 = CLIP(t29a - t26a); |
364 | 833k | t27a = CLIP(t28 - t27); |
365 | 833k | t28a = CLIP(t28 + t27); |
366 | 833k | t29 = CLIP(t29a + t26a); |
367 | 833k | t30a = CLIP(t30 + t25); |
368 | 833k | t31 = CLIP(t31a + t24a); |
369 | | |
370 | 833k | t20 = ((t27a - t20a) * 181 + 128) >> 8; |
371 | 833k | t27 = ((t27a + t20a) * 181 + 128) >> 8; |
372 | 833k | t21a = ((t26 - t21 ) * 181 + 128) >> 8; |
373 | 833k | t26a = ((t26 + t21 ) * 181 + 128) >> 8; |
374 | 833k | t22 = ((t25a - t22a) * 181 + 128) >> 8; |
375 | 833k | t25 = ((t25a + t22a) * 181 + 128) >> 8; |
376 | 833k | t23a = ((t24 - t23 ) * 181 + 128) >> 8; |
377 | 833k | t24a = ((t24 + t23 ) * 181 + 128) >> 8; |
378 | | |
379 | 833k | const int t0 = c[ 0 * stride]; |
380 | 833k | const int t1 = c[ 2 * stride]; |
381 | 833k | const int t2 = c[ 4 * stride]; |
382 | 833k | const int t3 = c[ 6 * stride]; |
383 | 833k | const int t4 = c[ 8 * stride]; |
384 | 833k | const int t5 = c[10 * stride]; |
385 | 833k | const int t6 = c[12 * stride]; |
386 | 833k | const int t7 = c[14 * stride]; |
387 | 833k | const int t8 = c[16 * stride]; |
388 | 833k | const int t9 = c[18 * stride]; |
389 | 833k | const int t10 = c[20 * stride]; |
390 | 833k | const int t11 = c[22 * stride]; |
391 | 833k | const int t12 = c[24 * stride]; |
392 | 833k | const int t13 = c[26 * stride]; |
393 | 833k | const int t14 = c[28 * stride]; |
394 | 833k | const int t15 = c[30 * stride]; |
395 | | |
396 | 833k | c[ 0 * stride] = CLIP(t0 + t31); |
397 | 833k | c[ 1 * stride] = CLIP(t1 + t30a); |
398 | 833k | c[ 2 * stride] = CLIP(t2 + t29); |
399 | 833k | c[ 3 * stride] = CLIP(t3 + t28a); |
400 | 833k | c[ 4 * stride] = CLIP(t4 + t27); |
401 | 833k | c[ 5 * stride] = CLIP(t5 + t26a); |
402 | 833k | c[ 6 * stride] = CLIP(t6 + t25); |
403 | 833k | c[ 7 * stride] = CLIP(t7 + t24a); |
404 | 833k | c[ 8 * stride] = CLIP(t8 + t23a); |
405 | 833k | c[ 9 * stride] = CLIP(t9 + t22); |
406 | 833k | c[10 * stride] = CLIP(t10 + t21a); |
407 | 833k | c[11 * stride] = CLIP(t11 + t20); |
408 | 833k | c[12 * stride] = CLIP(t12 + t19a); |
409 | 833k | c[13 * stride] = CLIP(t13 + t18); |
410 | 833k | c[14 * stride] = CLIP(t14 + t17a); |
411 | 833k | c[15 * stride] = CLIP(t15 + t16); |
412 | 833k | c[16 * stride] = CLIP(t15 - t16); |
413 | 833k | c[17 * stride] = CLIP(t14 - t17a); |
414 | 833k | c[18 * stride] = CLIP(t13 - t18); |
415 | 833k | c[19 * stride] = CLIP(t12 - t19a); |
416 | 833k | c[20 * stride] = CLIP(t11 - t20); |
417 | 833k | c[21 * stride] = CLIP(t10 - t21a); |
418 | 833k | c[22 * stride] = CLIP(t9 - t22); |
419 | 833k | c[23 * stride] = CLIP(t8 - t23a); |
420 | 833k | c[24 * stride] = CLIP(t7 - t24a); |
421 | 833k | c[25 * stride] = CLIP(t6 - t25); |
422 | 833k | c[26 * stride] = CLIP(t5 - t26a); |
423 | 833k | c[27 * stride] = CLIP(t4 - t27); |
424 | 833k | c[28 * stride] = CLIP(t3 - t28a); |
425 | 833k | c[29 * stride] = CLIP(t2 - t29); |
426 | 833k | c[30 * stride] = CLIP(t1 - t30a); |
427 | 833k | c[31 * stride] = CLIP(t0 - t31); |
428 | 833k | } |
429 | | |
430 | | static void inv_dct32_1d_c(int32_t *const c, const ptrdiff_t stride, |
431 | | const int min, const int max) |
432 | 532k | { |
433 | 532k | inv_dct32_1d_internal_c(c, stride, min, max, 0); |
434 | 532k | } |
435 | | |
436 | | static void inv_dct64_1d_c(int32_t *const c, const ptrdiff_t stride, |
437 | | const int min, const int max) |
438 | 300k | { |
439 | 300k | assert(stride > 0); |
440 | 300k | inv_dct32_1d_internal_c(c, stride << 1, min, max, 1); |
441 | | |
442 | 300k | const int in1 = c[ 1 * stride], in3 = c[ 3 * stride]; |
443 | 300k | const int in5 = c[ 5 * stride], in7 = c[ 7 * stride]; |
444 | 300k | const int in9 = c[ 9 * stride], in11 = c[11 * stride]; |
445 | 300k | const int in13 = c[13 * stride], in15 = c[15 * stride]; |
446 | 300k | const int in17 = c[17 * stride], in19 = c[19 * stride]; |
447 | 300k | const int in21 = c[21 * stride], in23 = c[23 * stride]; |
448 | 300k | const int in25 = c[25 * stride], in27 = c[27 * stride]; |
449 | 300k | const int in29 = c[29 * stride], in31 = c[31 * stride]; |
450 | | |
451 | 300k | int t32a = (in1 * 101 + 2048) >> 12; |
452 | 300k | int t33a = (in31 * -2824 + 2048) >> 12; |
453 | 300k | int t34a = (in17 * 1660 + 2048) >> 12; |
454 | 300k | int t35a = (in15 * -1474 + 2048) >> 12; |
455 | 300k | int t36a = (in9 * 897 + 2048) >> 12; |
456 | 300k | int t37a = (in23 * -2191 + 2048) >> 12; |
457 | 300k | int t38a = (in25 * 2359 + 2048) >> 12; |
458 | 300k | int t39a = (in7 * -700 + 2048) >> 12; |
459 | 300k | int t40a = (in5 * 501 + 2048) >> 12; |
460 | 300k | int t41a = (in27 * -2520 + 2048) >> 12; |
461 | 300k | int t42a = (in21 * 2019 + 2048) >> 12; |
462 | 300k | int t43a = (in11 * -1092 + 2048) >> 12; |
463 | 300k | int t44a = (in13 * 1285 + 2048) >> 12; |
464 | 300k | int t45a = (in19 * -1842 + 2048) >> 12; |
465 | 300k | int t46a = (in29 * 2675 + 2048) >> 12; |
466 | 300k | int t47a = (in3 * -301 + 2048) >> 12; |
467 | 300k | int t48a = (in3 * 4085 + 2048) >> 12; |
468 | 300k | int t49a = (in29 * 3102 + 2048) >> 12; |
469 | 300k | int t50a = (in19 * 3659 + 2048) >> 12; |
470 | 300k | int t51a = (in13 * 3889 + 2048) >> 12; |
471 | 300k | int t52a = (in11 * 3948 + 2048) >> 12; |
472 | 300k | int t53a = (in21 * 3564 + 2048) >> 12; |
473 | 300k | int t54a = (in27 * 3229 + 2048) >> 12; |
474 | 300k | int t55a = (in5 * 4065 + 2048) >> 12; |
475 | 300k | int t56a = (in7 * 4036 + 2048) >> 12; |
476 | 300k | int t57a = (in25 * 3349 + 2048) >> 12; |
477 | 300k | int t58a = (in23 * 3461 + 2048) >> 12; |
478 | 300k | int t59a = (in9 * 3996 + 2048) >> 12; |
479 | 300k | int t60a = (in15 * 3822 + 2048) >> 12; |
480 | 300k | int t61a = (in17 * 3745 + 2048) >> 12; |
481 | 300k | int t62a = (in31 * 2967 + 2048) >> 12; |
482 | 300k | int t63a = (in1 * 4095 + 2048) >> 12; |
483 | | |
484 | 300k | int t32 = CLIP(t32a + t33a); |
485 | 300k | int t33 = CLIP(t32a - t33a); |
486 | 300k | int t34 = CLIP(t35a - t34a); |
487 | 300k | int t35 = CLIP(t35a + t34a); |
488 | 300k | int t36 = CLIP(t36a + t37a); |
489 | 300k | int t37 = CLIP(t36a - t37a); |
490 | 300k | int t38 = CLIP(t39a - t38a); |
491 | 300k | int t39 = CLIP(t39a + t38a); |
492 | 300k | int t40 = CLIP(t40a + t41a); |
493 | 300k | int t41 = CLIP(t40a - t41a); |
494 | 300k | int t42 = CLIP(t43a - t42a); |
495 | 300k | int t43 = CLIP(t43a + t42a); |
496 | 300k | int t44 = CLIP(t44a + t45a); |
497 | 300k | int t45 = CLIP(t44a - t45a); |
498 | 300k | int t46 = CLIP(t47a - t46a); |
499 | 300k | int t47 = CLIP(t47a + t46a); |
500 | 300k | int t48 = CLIP(t48a + t49a); |
501 | 300k | int t49 = CLIP(t48a - t49a); |
502 | 300k | int t50 = CLIP(t51a - t50a); |
503 | 300k | int t51 = CLIP(t51a + t50a); |
504 | 300k | int t52 = CLIP(t52a + t53a); |
505 | 300k | int t53 = CLIP(t52a - t53a); |
506 | 300k | int t54 = CLIP(t55a - t54a); |
507 | 300k | int t55 = CLIP(t55a + t54a); |
508 | 300k | int t56 = CLIP(t56a + t57a); |
509 | 300k | int t57 = CLIP(t56a - t57a); |
510 | 300k | int t58 = CLIP(t59a - t58a); |
511 | 300k | int t59 = CLIP(t59a + t58a); |
512 | 300k | int t60 = CLIP(t60a + t61a); |
513 | 300k | int t61 = CLIP(t60a - t61a); |
514 | 300k | int t62 = CLIP(t63a - t62a); |
515 | 300k | int t63 = CLIP(t63a + t62a); |
516 | | |
517 | 300k | t33a = ((t33 * (4096 - 4076) + t62 * 401 + 2048) >> 12) - t33; |
518 | 300k | t34a = ((t34 * -401 + t61 * (4096 - 4076) + 2048) >> 12) - t61; |
519 | 300k | t37a = (t37 * -1299 + t58 * 1583 + 1024) >> 11; |
520 | 300k | t38a = (t38 * -1583 + t57 * -1299 + 1024) >> 11; |
521 | 300k | t41a = ((t41 * (4096 - 3612) + t54 * 1931 + 2048) >> 12) - t41; |
522 | 300k | t42a = ((t42 * -1931 + t53 * (4096 - 3612) + 2048) >> 12) - t53; |
523 | 300k | t45a = ((t45 * -1189 + t50 * (3920 - 4096) + 2048) >> 12) + t50; |
524 | 300k | t46a = ((t46 * (4096 - 3920) + t49 * -1189 + 2048) >> 12) - t46; |
525 | 300k | t49a = ((t46 * -1189 + t49 * (3920 - 4096) + 2048) >> 12) + t49; |
526 | 300k | t50a = ((t45 * (3920 - 4096) + t50 * 1189 + 2048) >> 12) + t45; |
527 | 300k | t53a = ((t42 * (4096 - 3612) + t53 * 1931 + 2048) >> 12) - t42; |
528 | 300k | t54a = ((t41 * 1931 + t54 * (3612 - 4096) + 2048) >> 12) + t54; |
529 | 300k | t57a = (t38 * -1299 + t57 * 1583 + 1024) >> 11; |
530 | 300k | t58a = (t37 * 1583 + t58 * 1299 + 1024) >> 11; |
531 | 300k | t61a = ((t34 * (4096 - 4076) + t61 * 401 + 2048) >> 12) - t34; |
532 | 300k | t62a = ((t33 * 401 + t62 * (4076 - 4096) + 2048) >> 12) + t62; |
533 | | |
534 | 300k | t32a = CLIP(t32 + t35); |
535 | 300k | t33 = CLIP(t33a + t34a); |
536 | 300k | t34 = CLIP(t33a - t34a); |
537 | 300k | t35a = CLIP(t32 - t35); |
538 | 300k | t36a = CLIP(t39 - t36); |
539 | 300k | t37 = CLIP(t38a - t37a); |
540 | 300k | t38 = CLIP(t38a + t37a); |
541 | 300k | t39a = CLIP(t39 + t36); |
542 | 300k | t40a = CLIP(t40 + t43); |
543 | 300k | t41 = CLIP(t41a + t42a); |
544 | 300k | t42 = CLIP(t41a - t42a); |
545 | 300k | t43a = CLIP(t40 - t43); |
546 | 300k | t44a = CLIP(t47 - t44); |
547 | 300k | t45 = CLIP(t46a - t45a); |
548 | 300k | t46 = CLIP(t46a + t45a); |
549 | 300k | t47a = CLIP(t47 + t44); |
550 | 300k | t48a = CLIP(t48 + t51); |
551 | 300k | t49 = CLIP(t49a + t50a); |
552 | 300k | t50 = CLIP(t49a - t50a); |
553 | 300k | t51a = CLIP(t48 - t51); |
554 | 300k | t52a = CLIP(t55 - t52); |
555 | 300k | t53 = CLIP(t54a - t53a); |
556 | 300k | t54 = CLIP(t54a + t53a); |
557 | 300k | t55a = CLIP(t55 + t52); |
558 | 300k | t56a = CLIP(t56 + t59); |
559 | 300k | t57 = CLIP(t57a + t58a); |
560 | 300k | t58 = CLIP(t57a - t58a); |
561 | 300k | t59a = CLIP(t56 - t59); |
562 | 300k | t60a = CLIP(t63 - t60); |
563 | 300k | t61 = CLIP(t62a - t61a); |
564 | 300k | t62 = CLIP(t62a + t61a); |
565 | 300k | t63a = CLIP(t63 + t60); |
566 | | |
567 | 300k | t34a = ((t34 * (4096 - 4017) + t61 * 799 + 2048) >> 12) - t34; |
568 | 300k | t35 = ((t35a * (4096 - 4017) + t60a * 799 + 2048) >> 12) - t35a; |
569 | 300k | t36 = ((t36a * -799 + t59a * (4096 - 4017) + 2048) >> 12) - t59a; |
570 | 300k | t37a = ((t37 * -799 + t58 * (4096 - 4017) + 2048) >> 12) - t58; |
571 | 300k | t42a = (t42 * -1138 + t53 * 1703 + 1024) >> 11; |
572 | 300k | t43 = (t43a * -1138 + t52a * 1703 + 1024) >> 11; |
573 | 300k | t44 = (t44a * -1703 + t51a * -1138 + 1024) >> 11; |
574 | 300k | t45a = (t45 * -1703 + t50 * -1138 + 1024) >> 11; |
575 | 300k | t50a = (t45 * -1138 + t50 * 1703 + 1024) >> 11; |
576 | 300k | t51 = (t44a * -1138 + t51a * 1703 + 1024) >> 11; |
577 | 300k | t52 = (t43a * 1703 + t52a * 1138 + 1024) >> 11; |
578 | 300k | t53a = (t42 * 1703 + t53 * 1138 + 1024) >> 11; |
579 | 300k | t58a = ((t37 * (4096 - 4017) + t58 * 799 + 2048) >> 12) - t37; |
580 | 300k | t59 = ((t36a * (4096 - 4017) + t59a * 799 + 2048) >> 12) - t36a; |
581 | 300k | t60 = ((t35a * 799 + t60a * (4017 - 4096) + 2048) >> 12) + t60a; |
582 | 300k | t61a = ((t34 * 799 + t61 * (4017 - 4096) + 2048) >> 12) + t61; |
583 | | |
584 | 300k | t32 = CLIP(t32a + t39a); |
585 | 300k | t33a = CLIP(t33 + t38); |
586 | 300k | t34 = CLIP(t34a + t37a); |
587 | 300k | t35a = CLIP(t35 + t36); |
588 | 300k | t36a = CLIP(t35 - t36); |
589 | 300k | t37 = CLIP(t34a - t37a); |
590 | 300k | t38a = CLIP(t33 - t38); |
591 | 300k | t39 = CLIP(t32a - t39a); |
592 | 300k | t40 = CLIP(t47a - t40a); |
593 | 300k | t41a = CLIP(t46 - t41); |
594 | 300k | t42 = CLIP(t45a - t42a); |
595 | 300k | t43a = CLIP(t44 - t43); |
596 | 300k | t44a = CLIP(t44 + t43); |
597 | 300k | t45 = CLIP(t45a + t42a); |
598 | 300k | t46a = CLIP(t46 + t41); |
599 | 300k | t47 = CLIP(t47a + t40a); |
600 | 300k | t48 = CLIP(t48a + t55a); |
601 | 300k | t49a = CLIP(t49 + t54); |
602 | 300k | t50 = CLIP(t50a + t53a); |
603 | 300k | t51a = CLIP(t51 + t52); |
604 | 300k | t52a = CLIP(t51 - t52); |
605 | 300k | t53 = CLIP(t50a - t53a); |
606 | 300k | t54a = CLIP(t49 - t54); |
607 | 300k | t55 = CLIP(t48a - t55a); |
608 | 300k | t56 = CLIP(t63a - t56a); |
609 | 300k | t57a = CLIP(t62 - t57); |
610 | 300k | t58 = CLIP(t61a - t58a); |
611 | 300k | t59a = CLIP(t60 - t59); |
612 | 300k | t60a = CLIP(t60 + t59); |
613 | 300k | t61 = CLIP(t61a + t58a); |
614 | 300k | t62a = CLIP(t62 + t57); |
615 | 300k | t63 = CLIP(t63a + t56a); |
616 | | |
617 | 300k | t36 = ((t36a * (4096 - 3784) + t59a * 1567 + 2048) >> 12) - t36a; |
618 | 300k | t37a = ((t37 * (4096 - 3784) + t58 * 1567 + 2048) >> 12) - t37; |
619 | 300k | t38 = ((t38a * (4096 - 3784) + t57a * 1567 + 2048) >> 12) - t38a; |
620 | 300k | t39a = ((t39 * (4096 - 3784) + t56 * 1567 + 2048) >> 12) - t39; |
621 | 300k | t40a = ((t40 * -1567 + t55 * (4096 - 3784) + 2048) >> 12) - t55; |
622 | 300k | t41 = ((t41a * -1567 + t54a * (4096 - 3784) + 2048) >> 12) - t54a; |
623 | 300k | t42a = ((t42 * -1567 + t53 * (4096 - 3784) + 2048) >> 12) - t53; |
624 | 300k | t43 = ((t43a * -1567 + t52a * (4096 - 3784) + 2048) >> 12) - t52a; |
625 | 300k | t52 = ((t43a * (4096 - 3784) + t52a * 1567 + 2048) >> 12) - t43a; |
626 | 300k | t53a = ((t42 * (4096 - 3784) + t53 * 1567 + 2048) >> 12) - t42; |
627 | 300k | t54 = ((t41a * (4096 - 3784) + t54a * 1567 + 2048) >> 12) - t41a; |
628 | 300k | t55a = ((t40 * (4096 - 3784) + t55 * 1567 + 2048) >> 12) - t40; |
629 | 300k | t56a = ((t39 * 1567 + t56 * (3784 - 4096) + 2048) >> 12) + t56; |
630 | 300k | t57 = ((t38a * 1567 + t57a * (3784 - 4096) + 2048) >> 12) + t57a; |
631 | 300k | t58a = ((t37 * 1567 + t58 * (3784 - 4096) + 2048) >> 12) + t58; |
632 | 300k | t59 = ((t36a * 1567 + t59a * (3784 - 4096) + 2048) >> 12) + t59a; |
633 | | |
634 | 300k | t32a = CLIP(t32 + t47); |
635 | 300k | t33 = CLIP(t33a + t46a); |
636 | 300k | t34a = CLIP(t34 + t45); |
637 | 300k | t35 = CLIP(t35a + t44a); |
638 | 300k | t36a = CLIP(t36 + t43); |
639 | 300k | t37 = CLIP(t37a + t42a); |
640 | 300k | t38a = CLIP(t38 + t41); |
641 | 300k | t39 = CLIP(t39a + t40a); |
642 | 300k | t40 = CLIP(t39a - t40a); |
643 | 300k | t41a = CLIP(t38 - t41); |
644 | 300k | t42 = CLIP(t37a - t42a); |
645 | 300k | t43a = CLIP(t36 - t43); |
646 | 300k | t44 = CLIP(t35a - t44a); |
647 | 300k | t45a = CLIP(t34 - t45); |
648 | 300k | t46 = CLIP(t33a - t46a); |
649 | 300k | t47a = CLIP(t32 - t47); |
650 | 300k | t48a = CLIP(t63 - t48); |
651 | 300k | t49 = CLIP(t62a - t49a); |
652 | 300k | t50a = CLIP(t61 - t50); |
653 | 300k | t51 = CLIP(t60a - t51a); |
654 | 300k | t52a = CLIP(t59 - t52); |
655 | 300k | t53 = CLIP(t58a - t53a); |
656 | 300k | t54a = CLIP(t57 - t54); |
657 | 300k | t55 = CLIP(t56a - t55a); |
658 | 300k | t56 = CLIP(t56a + t55a); |
659 | 300k | t57a = CLIP(t57 + t54); |
660 | 300k | t58 = CLIP(t58a + t53a); |
661 | 300k | t59a = CLIP(t59 + t52); |
662 | 300k | t60 = CLIP(t60a + t51a); |
663 | 300k | t61a = CLIP(t61 + t50); |
664 | 300k | t62 = CLIP(t62a + t49a); |
665 | 300k | t63a = CLIP(t63 + t48); |
666 | | |
667 | 300k | t40a = ((t55 - t40 ) * 181 + 128) >> 8; |
668 | 300k | t41 = ((t54a - t41a) * 181 + 128) >> 8; |
669 | 300k | t42a = ((t53 - t42 ) * 181 + 128) >> 8; |
670 | 300k | t43 = ((t52a - t43a) * 181 + 128) >> 8; |
671 | 300k | t44a = ((t51 - t44 ) * 181 + 128) >> 8; |
672 | 300k | t45 = ((t50a - t45a) * 181 + 128) >> 8; |
673 | 300k | t46a = ((t49 - t46 ) * 181 + 128) >> 8; |
674 | 300k | t47 = ((t48a - t47a) * 181 + 128) >> 8; |
675 | 300k | t48 = ((t47a + t48a) * 181 + 128) >> 8; |
676 | 300k | t49a = ((t46 + t49 ) * 181 + 128) >> 8; |
677 | 300k | t50 = ((t45a + t50a) * 181 + 128) >> 8; |
678 | 300k | t51a = ((t44 + t51 ) * 181 + 128) >> 8; |
679 | 300k | t52 = ((t43a + t52a) * 181 + 128) >> 8; |
680 | 300k | t53a = ((t42 + t53 ) * 181 + 128) >> 8; |
681 | 300k | t54 = ((t41a + t54a) * 181 + 128) >> 8; |
682 | 300k | t55a = ((t40 + t55 ) * 181 + 128) >> 8; |
683 | | |
684 | 300k | const int t0 = c[ 0 * stride]; |
685 | 300k | const int t1 = c[ 2 * stride]; |
686 | 300k | const int t2 = c[ 4 * stride]; |
687 | 300k | const int t3 = c[ 6 * stride]; |
688 | 300k | const int t4 = c[ 8 * stride]; |
689 | 300k | const int t5 = c[10 * stride]; |
690 | 300k | const int t6 = c[12 * stride]; |
691 | 300k | const int t7 = c[14 * stride]; |
692 | 300k | const int t8 = c[16 * stride]; |
693 | 300k | const int t9 = c[18 * stride]; |
694 | 300k | const int t10 = c[20 * stride]; |
695 | 300k | const int t11 = c[22 * stride]; |
696 | 300k | const int t12 = c[24 * stride]; |
697 | 300k | const int t13 = c[26 * stride]; |
698 | 300k | const int t14 = c[28 * stride]; |
699 | 300k | const int t15 = c[30 * stride]; |
700 | 300k | const int t16 = c[32 * stride]; |
701 | 300k | const int t17 = c[34 * stride]; |
702 | 300k | const int t18 = c[36 * stride]; |
703 | 300k | const int t19 = c[38 * stride]; |
704 | 300k | const int t20 = c[40 * stride]; |
705 | 300k | const int t21 = c[42 * stride]; |
706 | 300k | const int t22 = c[44 * stride]; |
707 | 300k | const int t23 = c[46 * stride]; |
708 | 300k | const int t24 = c[48 * stride]; |
709 | 300k | const int t25 = c[50 * stride]; |
710 | 300k | const int t26 = c[52 * stride]; |
711 | 300k | const int t27 = c[54 * stride]; |
712 | 300k | const int t28 = c[56 * stride]; |
713 | 300k | const int t29 = c[58 * stride]; |
714 | 300k | const int t30 = c[60 * stride]; |
715 | 300k | const int t31 = c[62 * stride]; |
716 | | |
717 | 300k | c[ 0 * stride] = CLIP(t0 + t63a); |
718 | 300k | c[ 1 * stride] = CLIP(t1 + t62); |
719 | 300k | c[ 2 * stride] = CLIP(t2 + t61a); |
720 | 300k | c[ 3 * stride] = CLIP(t3 + t60); |
721 | 300k | c[ 4 * stride] = CLIP(t4 + t59a); |
722 | 300k | c[ 5 * stride] = CLIP(t5 + t58); |
723 | 300k | c[ 6 * stride] = CLIP(t6 + t57a); |
724 | 300k | c[ 7 * stride] = CLIP(t7 + t56); |
725 | 300k | c[ 8 * stride] = CLIP(t8 + t55a); |
726 | 300k | c[ 9 * stride] = CLIP(t9 + t54); |
727 | 300k | c[10 * stride] = CLIP(t10 + t53a); |
728 | 300k | c[11 * stride] = CLIP(t11 + t52); |
729 | 300k | c[12 * stride] = CLIP(t12 + t51a); |
730 | 300k | c[13 * stride] = CLIP(t13 + t50); |
731 | 300k | c[14 * stride] = CLIP(t14 + t49a); |
732 | 300k | c[15 * stride] = CLIP(t15 + t48); |
733 | 300k | c[16 * stride] = CLIP(t16 + t47); |
734 | 300k | c[17 * stride] = CLIP(t17 + t46a); |
735 | 300k | c[18 * stride] = CLIP(t18 + t45); |
736 | 300k | c[19 * stride] = CLIP(t19 + t44a); |
737 | 300k | c[20 * stride] = CLIP(t20 + t43); |
738 | 300k | c[21 * stride] = CLIP(t21 + t42a); |
739 | 300k | c[22 * stride] = CLIP(t22 + t41); |
740 | 300k | c[23 * stride] = CLIP(t23 + t40a); |
741 | 300k | c[24 * stride] = CLIP(t24 + t39); |
742 | 300k | c[25 * stride] = CLIP(t25 + t38a); |
743 | 300k | c[26 * stride] = CLIP(t26 + t37); |
744 | 300k | c[27 * stride] = CLIP(t27 + t36a); |
745 | 300k | c[28 * stride] = CLIP(t28 + t35); |
746 | 300k | c[29 * stride] = CLIP(t29 + t34a); |
747 | 300k | c[30 * stride] = CLIP(t30 + t33); |
748 | 300k | c[31 * stride] = CLIP(t31 + t32a); |
749 | 300k | c[32 * stride] = CLIP(t31 - t32a); |
750 | 300k | c[33 * stride] = CLIP(t30 - t33); |
751 | 300k | c[34 * stride] = CLIP(t29 - t34a); |
752 | 300k | c[35 * stride] = CLIP(t28 - t35); |
753 | 300k | c[36 * stride] = CLIP(t27 - t36a); |
754 | 300k | c[37 * stride] = CLIP(t26 - t37); |
755 | 300k | c[38 * stride] = CLIP(t25 - t38a); |
756 | 300k | c[39 * stride] = CLIP(t24 - t39); |
757 | 300k | c[40 * stride] = CLIP(t23 - t40a); |
758 | 300k | c[41 * stride] = CLIP(t22 - t41); |
759 | 300k | c[42 * stride] = CLIP(t21 - t42a); |
760 | 300k | c[43 * stride] = CLIP(t20 - t43); |
761 | 300k | c[44 * stride] = CLIP(t19 - t44a); |
762 | 300k | c[45 * stride] = CLIP(t18 - t45); |
763 | 300k | c[46 * stride] = CLIP(t17 - t46a); |
764 | 300k | c[47 * stride] = CLIP(t16 - t47); |
765 | 300k | c[48 * stride] = CLIP(t15 - t48); |
766 | 300k | c[49 * stride] = CLIP(t14 - t49a); |
767 | 300k | c[50 * stride] = CLIP(t13 - t50); |
768 | 300k | c[51 * stride] = CLIP(t12 - t51a); |
769 | 300k | c[52 * stride] = CLIP(t11 - t52); |
770 | 300k | c[53 * stride] = CLIP(t10 - t53a); |
771 | 300k | c[54 * stride] = CLIP(t9 - t54); |
772 | 300k | c[55 * stride] = CLIP(t8 - t55a); |
773 | 300k | c[56 * stride] = CLIP(t7 - t56); |
774 | 300k | c[57 * stride] = CLIP(t6 - t57a); |
775 | 300k | c[58 * stride] = CLIP(t5 - t58); |
776 | 300k | c[59 * stride] = CLIP(t4 - t59a); |
777 | 300k | c[60 * stride] = CLIP(t3 - t60); |
778 | 300k | c[61 * stride] = CLIP(t2 - t61a); |
779 | 300k | c[62 * stride] = CLIP(t1 - t62); |
780 | 300k | c[63 * stride] = CLIP(t0 - t63a); |
781 | 300k | } |
782 | | |
783 | | static NOINLINE void |
784 | | inv_adst4_1d_internal_c(const int32_t *const in, const ptrdiff_t in_s, |
785 | | const int min, const int max, |
786 | | int32_t *const out, const ptrdiff_t out_s) |
787 | 126k | { |
788 | 126k | assert(in_s > 0 && out_s != 0); |
789 | 126k | const int in0 = in[0 * in_s], in1 = in[1 * in_s]; |
790 | 126k | const int in2 = in[2 * in_s], in3 = in[3 * in_s]; |
791 | | |
792 | 126k | out[0 * out_s] = (( 1321 * in0 + (3803 - 4096) * in2 + |
793 | 126k | (2482 - 4096) * in3 + (3344 - 4096) * in1 + 2048) >> 12) + |
794 | 126k | in2 + in3 + in1; |
795 | 126k | out[1 * out_s] = (((2482 - 4096) * in0 - 1321 * in2 - |
796 | 126k | (3803 - 4096) * in3 + (3344 - 4096) * in1 + 2048) >> 12) + |
797 | 126k | in0 - in3 + in1; |
798 | 126k | out[2 * out_s] = (209 * (in0 - in2 + in3) + 128) >> 8; |
799 | 126k | out[3 * out_s] = (((3803 - 4096) * in0 + (2482 - 4096) * in2 - |
800 | 126k | 1321 * in3 - (3344 - 4096) * in1 + 2048) >> 12) + |
801 | 126k | in0 + in2 - in1; |
802 | 126k | } |
803 | | |
804 | | static NOINLINE void |
805 | | inv_adst8_1d_internal_c(const int32_t *const in, const ptrdiff_t in_s, |
806 | | const int min, const int max, |
807 | | int32_t *const out, const ptrdiff_t out_s) |
808 | 226k | { |
809 | 226k | assert(in_s > 0 && out_s != 0); |
810 | 226k | const int in0 = in[0 * in_s], in1 = in[1 * in_s]; |
811 | 226k | const int in2 = in[2 * in_s], in3 = in[3 * in_s]; |
812 | 226k | const int in4 = in[4 * in_s], in5 = in[5 * in_s]; |
813 | 226k | const int in6 = in[6 * in_s], in7 = in[7 * in_s]; |
814 | | |
815 | 226k | const int t0a = (((4076 - 4096) * in7 + 401 * in0 + 2048) >> 12) + in7; |
816 | 226k | const int t1a = (( 401 * in7 - (4076 - 4096) * in0 + 2048) >> 12) - in0; |
817 | 226k | const int t2a = (((3612 - 4096) * in5 + 1931 * in2 + 2048) >> 12) + in5; |
818 | 226k | const int t3a = (( 1931 * in5 - (3612 - 4096) * in2 + 2048) >> 12) - in2; |
819 | 226k | int t4a = ( 1299 * in3 + 1583 * in4 + 1024) >> 11; |
820 | 226k | int t5a = ( 1583 * in3 - 1299 * in4 + 1024) >> 11; |
821 | 226k | int t6a = (( 1189 * in1 + (3920 - 4096) * in6 + 2048) >> 12) + in6; |
822 | 226k | int t7a = (((3920 - 4096) * in1 - 1189 * in6 + 2048) >> 12) + in1; |
823 | | |
824 | 226k | const int t0 = CLIP(t0a + t4a); |
825 | 226k | const int t1 = CLIP(t1a + t5a); |
826 | 226k | int t2 = CLIP(t2a + t6a); |
827 | 226k | int t3 = CLIP(t3a + t7a); |
828 | 226k | const int t4 = CLIP(t0a - t4a); |
829 | 226k | const int t5 = CLIP(t1a - t5a); |
830 | 226k | int t6 = CLIP(t2a - t6a); |
831 | 226k | int t7 = CLIP(t3a - t7a); |
832 | | |
833 | 226k | t4a = (((3784 - 4096) * t4 + 1567 * t5 + 2048) >> 12) + t4; |
834 | 226k | t5a = (( 1567 * t4 - (3784 - 4096) * t5 + 2048) >> 12) - t5; |
835 | 226k | t6a = (((3784 - 4096) * t7 - 1567 * t6 + 2048) >> 12) + t7; |
836 | 226k | t7a = (( 1567 * t7 + (3784 - 4096) * t6 + 2048) >> 12) + t6; |
837 | | |
838 | 226k | out[0 * out_s] = CLIP(t0 + t2 ); |
839 | 226k | out[7 * out_s] = -CLIP(t1 + t3 ); |
840 | 226k | t2 = CLIP(t0 - t2 ); |
841 | 226k | t3 = CLIP(t1 - t3 ); |
842 | 226k | out[1 * out_s] = -CLIP(t4a + t6a); |
843 | 226k | out[6 * out_s] = CLIP(t5a + t7a); |
844 | 226k | t6 = CLIP(t4a - t6a); |
845 | 226k | t7 = CLIP(t5a - t7a); |
846 | | |
847 | 226k | out[3 * out_s] = -(((t2 + t3) * 181 + 128) >> 8); |
848 | 226k | out[4 * out_s] = ((t2 - t3) * 181 + 128) >> 8; |
849 | 226k | out[2 * out_s] = ((t6 + t7) * 181 + 128) >> 8; |
850 | 226k | out[5 * out_s] = -(((t6 - t7) * 181 + 128) >> 8); |
851 | 226k | } |
852 | | |
853 | | static NOINLINE void |
854 | | inv_adst16_1d_internal_c(const int32_t *const in, const ptrdiff_t in_s, |
855 | | const int min, const int max, |
856 | | int32_t *const out, const ptrdiff_t out_s) |
857 | 184k | { |
858 | 184k | assert(in_s > 0 && out_s != 0); |
859 | 184k | const int in0 = in[ 0 * in_s], in1 = in[ 1 * in_s]; |
860 | 184k | const int in2 = in[ 2 * in_s], in3 = in[ 3 * in_s]; |
861 | 184k | const int in4 = in[ 4 * in_s], in5 = in[ 5 * in_s]; |
862 | 184k | const int in6 = in[ 6 * in_s], in7 = in[ 7 * in_s]; |
863 | 184k | const int in8 = in[ 8 * in_s], in9 = in[ 9 * in_s]; |
864 | 184k | const int in10 = in[10 * in_s], in11 = in[11 * in_s]; |
865 | 184k | const int in12 = in[12 * in_s], in13 = in[13 * in_s]; |
866 | 184k | const int in14 = in[14 * in_s], in15 = in[15 * in_s]; |
867 | | |
868 | 184k | int t0 = ((in15 * (4091 - 4096) + in0 * 201 + 2048) >> 12) + in15; |
869 | 184k | int t1 = ((in15 * 201 - in0 * (4091 - 4096) + 2048) >> 12) - in0; |
870 | 184k | int t2 = ((in13 * (3973 - 4096) + in2 * 995 + 2048) >> 12) + in13; |
871 | 184k | int t3 = ((in13 * 995 - in2 * (3973 - 4096) + 2048) >> 12) - in2; |
872 | 184k | int t4 = ((in11 * (3703 - 4096) + in4 * 1751 + 2048) >> 12) + in11; |
873 | 184k | int t5 = ((in11 * 1751 - in4 * (3703 - 4096) + 2048) >> 12) - in4; |
874 | 184k | int t6 = (in9 * 1645 + in6 * 1220 + 1024) >> 11; |
875 | 184k | int t7 = (in9 * 1220 - in6 * 1645 + 1024) >> 11; |
876 | 184k | int t8 = ((in7 * 2751 + in8 * (3035 - 4096) + 2048) >> 12) + in8; |
877 | 184k | int t9 = ((in7 * (3035 - 4096) - in8 * 2751 + 2048) >> 12) + in7; |
878 | 184k | int t10 = ((in5 * 2106 + in10 * (3513 - 4096) + 2048) >> 12) + in10; |
879 | 184k | int t11 = ((in5 * (3513 - 4096) - in10 * 2106 + 2048) >> 12) + in5; |
880 | 184k | int t12 = ((in3 * 1380 + in12 * (3857 - 4096) + 2048) >> 12) + in12; |
881 | 184k | int t13 = ((in3 * (3857 - 4096) - in12 * 1380 + 2048) >> 12) + in3; |
882 | 184k | int t14 = ((in1 * 601 + in14 * (4052 - 4096) + 2048) >> 12) + in14; |
883 | 184k | int t15 = ((in1 * (4052 - 4096) - in14 * 601 + 2048) >> 12) + in1; |
884 | | |
885 | 184k | int t0a = CLIP(t0 + t8 ); |
886 | 184k | int t1a = CLIP(t1 + t9 ); |
887 | 184k | int t2a = CLIP(t2 + t10); |
888 | 184k | int t3a = CLIP(t3 + t11); |
889 | 184k | int t4a = CLIP(t4 + t12); |
890 | 184k | int t5a = CLIP(t5 + t13); |
891 | 184k | int t6a = CLIP(t6 + t14); |
892 | 184k | int t7a = CLIP(t7 + t15); |
893 | 184k | int t8a = CLIP(t0 - t8 ); |
894 | 184k | int t9a = CLIP(t1 - t9 ); |
895 | 184k | int t10a = CLIP(t2 - t10); |
896 | 184k | int t11a = CLIP(t3 - t11); |
897 | 184k | int t12a = CLIP(t4 - t12); |
898 | 184k | int t13a = CLIP(t5 - t13); |
899 | 184k | int t14a = CLIP(t6 - t14); |
900 | 184k | int t15a = CLIP(t7 - t15); |
901 | | |
902 | 184k | t8 = ((t8a * (4017 - 4096) + t9a * 799 + 2048) >> 12) + t8a; |
903 | 184k | t9 = ((t8a * 799 - t9a * (4017 - 4096) + 2048) >> 12) - t9a; |
904 | 184k | t10 = ((t10a * 2276 + t11a * (3406 - 4096) + 2048) >> 12) + t11a; |
905 | 184k | t11 = ((t10a * (3406 - 4096) - t11a * 2276 + 2048) >> 12) + t10a; |
906 | 184k | t12 = ((t13a * (4017 - 4096) - t12a * 799 + 2048) >> 12) + t13a; |
907 | 184k | t13 = ((t13a * 799 + t12a * (4017 - 4096) + 2048) >> 12) + t12a; |
908 | 184k | t14 = ((t15a * 2276 - t14a * (3406 - 4096) + 2048) >> 12) - t14a; |
909 | 184k | t15 = ((t15a * (3406 - 4096) + t14a * 2276 + 2048) >> 12) + t15a; |
910 | | |
911 | 184k | t0 = CLIP(t0a + t4a); |
912 | 184k | t1 = CLIP(t1a + t5a); |
913 | 184k | t2 = CLIP(t2a + t6a); |
914 | 184k | t3 = CLIP(t3a + t7a); |
915 | 184k | t4 = CLIP(t0a - t4a); |
916 | 184k | t5 = CLIP(t1a - t5a); |
917 | 184k | t6 = CLIP(t2a - t6a); |
918 | 184k | t7 = CLIP(t3a - t7a); |
919 | 184k | t8a = CLIP(t8 + t12); |
920 | 184k | t9a = CLIP(t9 + t13); |
921 | 184k | t10a = CLIP(t10 + t14); |
922 | 184k | t11a = CLIP(t11 + t15); |
923 | 184k | t12a = CLIP(t8 - t12); |
924 | 184k | t13a = CLIP(t9 - t13); |
925 | 184k | t14a = CLIP(t10 - t14); |
926 | 184k | t15a = CLIP(t11 - t15); |
927 | | |
928 | 184k | t4a = ((t4 * (3784 - 4096) + t5 * 1567 + 2048) >> 12) + t4; |
929 | 184k | t5a = ((t4 * 1567 - t5 * (3784 - 4096) + 2048) >> 12) - t5; |
930 | 184k | t6a = ((t7 * (3784 - 4096) - t6 * 1567 + 2048) >> 12) + t7; |
931 | 184k | t7a = ((t7 * 1567 + t6 * (3784 - 4096) + 2048) >> 12) + t6; |
932 | 184k | t12 = ((t12a * (3784 - 4096) + t13a * 1567 + 2048) >> 12) + t12a; |
933 | 184k | t13 = ((t12a * 1567 - t13a * (3784 - 4096) + 2048) >> 12) - t13a; |
934 | 184k | t14 = ((t15a * (3784 - 4096) - t14a * 1567 + 2048) >> 12) + t15a; |
935 | 184k | t15 = ((t15a * 1567 + t14a * (3784 - 4096) + 2048) >> 12) + t14a; |
936 | | |
937 | 184k | out[ 0 * out_s] = CLIP(t0 + t2 ); |
938 | 184k | out[15 * out_s] = -CLIP(t1 + t3 ); |
939 | 184k | t2a = CLIP(t0 - t2 ); |
940 | 184k | t3a = CLIP(t1 - t3 ); |
941 | 184k | out[ 3 * out_s] = -CLIP(t4a + t6a ); |
942 | 184k | out[12 * out_s] = CLIP(t5a + t7a ); |
943 | 184k | t6 = CLIP(t4a - t6a ); |
944 | 184k | t7 = CLIP(t5a - t7a ); |
945 | 184k | out[ 1 * out_s] = -CLIP(t8a + t10a); |
946 | 184k | out[14 * out_s] = CLIP(t9a + t11a); |
947 | 184k | t10 = CLIP(t8a - t10a); |
948 | 184k | t11 = CLIP(t9a - t11a); |
949 | 184k | out[ 2 * out_s] = CLIP(t12 + t14 ); |
950 | 184k | out[13 * out_s] = -CLIP(t13 + t15 ); |
951 | 184k | t14a = CLIP(t12 - t14 ); |
952 | 184k | t15a = CLIP(t13 - t15 ); |
953 | | |
954 | 184k | out[ 7 * out_s] = -(((t2a + t3a) * 181 + 128) >> 8); |
955 | 184k | out[ 8 * out_s] = ((t2a - t3a) * 181 + 128) >> 8; |
956 | 184k | out[ 4 * out_s] = ((t6 + t7) * 181 + 128) >> 8; |
957 | 184k | out[11 * out_s] = -(((t6 - t7) * 181 + 128) >> 8); |
958 | 184k | out[ 6 * out_s] = ((t10 + t11) * 181 + 128) >> 8; |
959 | 184k | out[ 9 * out_s] = -(((t10 - t11) * 181 + 128) >> 8); |
960 | 184k | out[ 5 * out_s] = -(((t14a + t15a) * 181 + 128) >> 8); |
961 | 184k | out[10 * out_s] = ((t14a - t15a) * 181 + 128) >> 8; |
962 | 184k | } |
963 | | |
964 | | #define inv_adst_1d(sz) \ |
965 | | static void inv_adst##sz##_1d_c(int32_t *const c, const ptrdiff_t stride, \ |
966 | 468k | const int min, const int max) \ |
967 | 468k | { \ |
968 | 468k | inv_adst##sz##_1d_internal_c(c, stride, min, max, c, stride); \ |
969 | 468k | } \ Line | Count | Source | 966 | 108k | const int min, const int max) \ | 967 | 108k | { \ | 968 | 108k | inv_adst##sz##_1d_internal_c(c, stride, min, max, c, stride); \ | 969 | 108k | } \ |
Line | Count | Source | 966 | 194k | const int min, const int max) \ | 967 | 194k | { \ | 968 | 194k | inv_adst##sz##_1d_internal_c(c, stride, min, max, c, stride); \ | 969 | 194k | } \ |
Line | Count | Source | 966 | 165k | const int min, const int max) \ | 967 | 165k | { \ | 968 | 165k | inv_adst##sz##_1d_internal_c(c, stride, min, max, c, stride); \ | 969 | 165k | } \ |
|
970 | | static void inv_flipadst##sz##_1d_c(int32_t *const c, const ptrdiff_t stride, \ |
971 | 69.4k | const int min, const int max) \ |
972 | 69.4k | { \ |
973 | 69.4k | inv_adst##sz##_1d_internal_c(c, stride, min, max, \ |
974 | 69.4k | &c[(sz - 1) * stride], -stride); \ |
975 | 69.4k | } itx_1d.c:inv_flipadst4_1d_c Line | Count | Source | 971 | 18.3k | const int min, const int max) \ | 972 | 18.3k | { \ | 973 | 18.3k | inv_adst##sz##_1d_internal_c(c, stride, min, max, \ | 974 | 18.3k | &c[(sz - 1) * stride], -stride); \ | 975 | 18.3k | } |
itx_1d.c:inv_flipadst8_1d_c Line | Count | Source | 971 | 31.6k | const int min, const int max) \ | 972 | 31.6k | { \ | 973 | 31.6k | inv_adst##sz##_1d_internal_c(c, stride, min, max, \ | 974 | 31.6k | &c[(sz - 1) * stride], -stride); \ | 975 | 31.6k | } |
itx_1d.c:inv_flipadst16_1d_c Line | Count | Source | 971 | 19.4k | const int min, const int max) \ | 972 | 19.4k | { \ | 973 | 19.4k | inv_adst##sz##_1d_internal_c(c, stride, min, max, \ | 974 | 19.4k | &c[(sz - 1) * stride], -stride); \ | 975 | 19.4k | } |
|
976 | | |
977 | | inv_adst_1d( 4) |
978 | | inv_adst_1d( 8) |
979 | | inv_adst_1d(16) |
980 | | |
981 | | #undef inv_adst_1d |
982 | | |
983 | | static void inv_identity4_1d_c(int32_t *const c, const ptrdiff_t stride, |
984 | | const int min, const int max) |
985 | 55.0k | { |
986 | 55.0k | assert(stride > 0); |
987 | 275k | for (int i = 0; i < 4; i++) { |
988 | 220k | const int in = c[stride * i]; |
989 | 220k | c[stride * i] = in + ((in * 1697 + 2048) >> 12); |
990 | 220k | } |
991 | 55.0k | } |
992 | | |
993 | | static void inv_identity8_1d_c(int32_t *const c, const ptrdiff_t stride, |
994 | | const int min, const int max) |
995 | 84.4k | { |
996 | 84.4k | assert(stride > 0); |
997 | 759k | for (int i = 0; i < 8; i++) |
998 | 675k | c[stride * i] *= 2; |
999 | 84.4k | } |
1000 | | |
1001 | | static void inv_identity16_1d_c(int32_t *const c, const ptrdiff_t stride, |
1002 | | const int min, const int max) |
1003 | 39.6k | { |
1004 | 39.6k | assert(stride > 0); |
1005 | 674k | for (int i = 0; i < 16; i++) { |
1006 | 634k | const int in = c[stride * i]; |
1007 | 634k | c[stride * i] = 2 * in + ((in * 1697 + 1024) >> 11); |
1008 | 634k | } |
1009 | 39.6k | } |
1010 | | |
1011 | | static void inv_identity32_1d_c(int32_t *const c, const ptrdiff_t stride, |
1012 | | const int min, const int max) |
1013 | 9.36k | { |
1014 | 9.36k | assert(stride > 0); |
1015 | 309k | for (int i = 0; i < 32; i++) |
1016 | 299k | c[stride * i] *= 4; |
1017 | 9.36k | } |
1018 | | |
1019 | | const itx_1d_fn dav1d_tx1d_fns[N_TX_SIZES][N_TX_1D_TYPES] = { |
1020 | | [TX_4X4] = { |
1021 | | [DCT] = inv_dct4_1d_c, |
1022 | | [ADST] = inv_adst4_1d_c, |
1023 | | [FLIPADST] = inv_flipadst4_1d_c, |
1024 | | [IDENTITY] = inv_identity4_1d_c, |
1025 | | }, [TX_8X8] = { |
1026 | | [DCT] = inv_dct8_1d_c, |
1027 | | [ADST] = inv_adst8_1d_c, |
1028 | | [FLIPADST] = inv_flipadst8_1d_c, |
1029 | | [IDENTITY] = inv_identity8_1d_c, |
1030 | | }, [TX_16X16] = { |
1031 | | [DCT] = inv_dct16_1d_c, |
1032 | | [ADST] = inv_adst16_1d_c, |
1033 | | [FLIPADST] = inv_flipadst16_1d_c, |
1034 | | [IDENTITY] = inv_identity16_1d_c, |
1035 | | }, [TX_32X32] = { |
1036 | | [DCT] = inv_dct32_1d_c, |
1037 | | [IDENTITY] = inv_identity32_1d_c, |
1038 | | }, [TX_64X64] = { |
1039 | | [DCT] = inv_dct64_1d_c, |
1040 | | }, |
1041 | | }; |
1042 | | |
1043 | | const uint8_t /* enum Tx1dType */ dav1d_tx1d_types[N_TX_TYPES][2] = { |
1044 | | [DCT_DCT] = { DCT, DCT }, |
1045 | | [ADST_DCT] = { ADST, DCT }, |
1046 | | [DCT_ADST] = { DCT, ADST }, |
1047 | | [ADST_ADST] = { ADST, ADST }, |
1048 | | [FLIPADST_DCT] = { FLIPADST, DCT }, |
1049 | | [DCT_FLIPADST] = { DCT, FLIPADST }, |
1050 | | [FLIPADST_FLIPADST] = { FLIPADST, FLIPADST }, |
1051 | | [ADST_FLIPADST] = { ADST, FLIPADST }, |
1052 | | [FLIPADST_ADST] = { FLIPADST, ADST }, |
1053 | | [IDTX] = { IDENTITY, IDENTITY }, |
1054 | | [V_DCT] = { DCT, IDENTITY }, |
1055 | | [H_DCT] = { IDENTITY, DCT }, |
1056 | | [V_ADST] = { ADST, IDENTITY }, |
1057 | | [H_ADST] = { IDENTITY, ADST }, |
1058 | | [V_FLIPADST] = { FLIPADST, IDENTITY }, |
1059 | | [H_FLIPADST] = { IDENTITY, FLIPADST }, |
1060 | | }; |
1061 | | |
1062 | | #if !(HAVE_ASM && TRIM_DSP_FUNCTIONS && ( \ |
1063 | | ARCH_AARCH64 || \ |
1064 | | (ARCH_ARM && (defined(__ARM_NEON) || defined(__APPLE__) || defined(_WIN32))) \ |
1065 | | )) |
1066 | 1.24M | void dav1d_inv_wht4_1d_c(int32_t *const c, const ptrdiff_t stride) { |
1067 | 1.24M | assert(stride > 0); |
1068 | 1.24M | const int in0 = c[0 * stride], in1 = c[1 * stride]; |
1069 | 1.24M | const int in2 = c[2 * stride], in3 = c[3 * stride]; |
1070 | | |
1071 | 1.24M | const int t0 = in0 + in1; |
1072 | 1.24M | const int t2 = in2 - in3; |
1073 | 1.24M | const int t4 = (t0 - t2) >> 1; |
1074 | 1.24M | const int t3 = t4 - in3; |
1075 | 1.24M | const int t1 = t4 - in1; |
1076 | | |
1077 | 1.24M | c[0 * stride] = t0 - t3; |
1078 | 1.24M | c[1 * stride] = t3; |
1079 | 1.24M | c[2 * stride] = t1; |
1080 | 1.24M | c[3 * stride] = t2 + t1; |
1081 | 1.24M | } |
1082 | | #endif |