1 /*
2 * This file is part of the Independent JPEG Group's software.
3 *
4 * The authors make NO WARRANTY or representation, either express or implied,
5 * with respect to this software, its quality, accuracy, merchantability, or
6 * fitness for a particular purpose. This software is provided "AS IS", and
7 * you, its user, assume the entire risk as to its quality and accuracy.
8 *
9 * This software is copyright (C) 1991, 1992, Thomas G. Lane.
10 * All Rights Reserved except as specified below.
11 *
12 * Permission is hereby granted to use, copy, modify, and distribute this
13 * software (or portions thereof) for any purpose, without fee, subject to
14 * these conditions:
15 * (1) If any part of the source code for this software is distributed, then
16 * this README file must be included, with this copyright and no-warranty
17 * notice unaltered; and any additions, deletions, or changes to the original
18 * files must be clearly indicated in accompanying documentation.
19 * (2) If only executable code is distributed, then the accompanying
20 * documentation must state that "this software is based in part on the work
21 * of the Independent JPEG Group".
22 * (3) Permission for use of this software is granted only if the user accepts
23 * full responsibility for any undesirable consequences; the authors accept
24 * NO LIABILITY for damages of any kind.
25 *
26 * These conditions apply to any software derived from or based on the IJG
27 * code, not just to the unmodified library. If you use our work, you ought
28 * to acknowledge us.
29 *
30 * Permission is NOT granted for the use of any IJG author's name or company
31 * name in advertising or publicity relating to this software or products
32 * derived from it. This software may be referred to only as "the Independent
33 * JPEG Group's software".
34 *
35 * We specifically permit and encourage the use of this software as the basis
36 * of commercial products, provided that all warranty or liability claims are
37 * assumed by the product vendor.
38 *
39 * This file contains the basic inverse-DCT transformation subroutine.
40 *
41 * This implementation is based on an algorithm described in
42 * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
43 * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
44 * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
45 * The primary algorithm described there uses 11 multiplies and 29 adds.
46 * We use their alternate method with 12 multiplies and 32 adds.
47 * The advantage of this method is that no data path contains more than one
48 * multiplication; this allows a very simple and accurate implementation in
49 * scaled fixed-point arithmetic, with a minimal number of shifts.
50 *
51 * I've made lots of modifications to attempt to take advantage of the
52 * sparse nature of the DCT matrices we're getting. Although the logic
53 * is cumbersome, it's straightforward and the resulting code is much
54 * faster.
55 *
56 * A better way to do this would be to pass in the DCT block as a sparse
57 * matrix, perhaps with the difference cases encoded.
58 */
59
60 /**
61 * @file
62 * Independent JPEG Group's LLM idct.
63 */
64
65 #include "libavutil/common.h"
66 #include "libavutil/intreadwrite.h"
67
68 #include "dct.h"
69 #include "idctdsp.h"
70
71 #define EIGHT_BIT_SAMPLES
72
73 #define DCTSIZE 8
74 #define DCTSIZE2 64
75
76 #define GLOBAL
77
78 #define RIGHT_SHIFT(x, n) ((x) >> (n))
79
80 typedef int16_t DCTBLOCK[DCTSIZE2];
81
82 #define CONST_BITS 13
83
84 /*
85 * This routine is specialized to the case DCTSIZE = 8.
86 */
87
88 #if DCTSIZE != 8
89 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
90 #endif
91
92
93 /*
94 * A 2-D IDCT can be done by 1-D IDCT on each row followed by 1-D IDCT
95 * on each column. Direct algorithms are also available, but they are
96 * much more complex and seem not to be any faster when reduced to code.
97 *
98 * The poop on this scaling stuff is as follows:
99 *
100 * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
101 * larger than the true IDCT outputs. The final outputs are therefore
102 * a factor of N larger than desired; since N=8 this can be cured by
103 * a simple right shift at the end of the algorithm. The advantage of
104 * this arrangement is that we save two multiplications per 1-D IDCT,
105 * because the y0 and y4 inputs need not be divided by sqrt(N).
106 *
107 * We have to do addition and subtraction of the integer inputs, which
108 * is no problem, and multiplication by fractional constants, which is
109 * a problem to do in integer arithmetic. We multiply all the constants
110 * by CONST_SCALE and convert them to integer constants (thus retaining
111 * CONST_BITS bits of precision in the constants). After doing a
112 * multiplication we have to divide the product by CONST_SCALE, with proper
113 * rounding, to produce the correct output. This division can be done
114 * cheaply as a right shift of CONST_BITS bits. We postpone shifting
115 * as long as possible so that partial sums can be added together with
116 * full fractional precision.
117 *
118 * The outputs of the first pass are scaled up by PASS1_BITS bits so that
119 * they are represented to better-than-integral precision. These outputs
120 * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
121 * with the recommended scaling. (To scale up 12-bit sample data further, an
122 * intermediate int32 array would be needed.)
123 *
124 * To avoid overflow of the 32-bit intermediate results in pass 2, we must
125 * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis
126 * shows that the values given below are the most effective.
127 */
128
129 #ifdef EIGHT_BIT_SAMPLES
130 #define PASS1_BITS 2
131 #else
132 #define PASS1_BITS 1 /* lose a little precision to avoid overflow */
133 #endif
134
135 #define ONE ((int32_t) 1)
136
137 #define CONST_SCALE (ONE << CONST_BITS)
138
139 /* Convert a positive real constant to an integer scaled by CONST_SCALE.
140 * IMPORTANT: if your compiler doesn't do this arithmetic at compile time,
141 * you will pay a significant penalty in run time. In that case, figure
142 * the correct integer constant values and insert them by hand.
143 */
144
145 /* Actually FIX is no longer used, we precomputed them all */
146 #define FIX(x) ((int32_t) ((x) * CONST_SCALE + 0.5))
147
148 /* Descale and correctly round an int32_t value that's scaled by N bits.
149 * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
150 * the fudge factor is correct for either sign of X.
151 */
152
153 #define DESCALE(x,n) RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
154
155 /* Multiply an int32_t variable by an int32_t constant to yield an int32_t result.
156 * For 8-bit samples with the recommended scaling, all the variable
157 * and constant values involved are no more than 16 bits wide, so a
158 * 16x16->32 bit multiply can be used instead of a full 32x32 multiply;
159 * this provides a useful speedup on many machines.
160 * There is no way to specify a 16x16->32 multiply in portable C, but
161 * some C compilers will do the right thing if you provide the correct
162 * combination of casts.
163 * NB: for 12-bit samples, a full 32-bit multiplication will be needed.
164 */
165
166 #ifdef EIGHT_BIT_SAMPLES
167 #ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */
168 #define MULTIPLY(var,const) (((int16_t) (var)) * ((int16_t) (const)))
169 #endif
170 #ifdef SHORTxLCONST_32 /* known to work with Microsoft C 6.0 */
171 #define MULTIPLY(var,const) (((int16_t) (var)) * ((int32_t) (const)))
172 #endif
173 #endif
174
175 #ifndef MULTIPLY /* default definition */
176 #define MULTIPLY(var,const) ((var) * (const))
177 #endif
178
179
180 /*
181 Unlike our decoder where we approximate the FIXes, we need to use exact
182 ones here or successive P-frames will drift too much with Reference frame coding
183 */
184 #define FIX_0_211164243 1730
185 #define FIX_0_275899380 2260
186 #define FIX_0_298631336 2446
187 #define FIX_0_390180644 3196
188 #define FIX_0_509795579 4176
189 #define FIX_0_541196100 4433
190 #define FIX_0_601344887 4926
191 #define FIX_0_765366865 6270
192 #define FIX_0_785694958 6436
193 #define FIX_0_899976223 7373
194 #define FIX_1_061594337 8697
195 #define FIX_1_111140466 9102
196 #define FIX_1_175875602 9633
197 #define FIX_1_306562965 10703
198 #define FIX_1_387039845 11363
199 #define FIX_1_451774981 11893
200 #define FIX_1_501321110 12299
201 #define FIX_1_662939225 13623
202 #define FIX_1_847759065 15137
203 #define FIX_1_961570560 16069
204 #define FIX_2_053119869 16819
205 #define FIX_2_172734803 17799
206 #define FIX_2_562915447 20995
207 #define FIX_3_072711026 25172
208
209 /*
210 * Perform the inverse DCT on one block of coefficients.
211 */
212
213 void ff_j_rev_dct(DCTBLOCK data)
214 {
215 int32_t tmp0, tmp1, tmp2, tmp3;
216 int32_t tmp10, tmp11, tmp12, tmp13;
217 int32_t z1, z2, z3, z4, z5;
218 int32_t d0, d1, d2, d3, d4, d5, d6, d7;
219 register int16_t *dataptr;
220 int rowctr;
221
222 /* Pass 1: process rows. */
223 /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
224 /* furthermore, we scale the results by 2**PASS1_BITS. */
225
226 dataptr = data;
227
228 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
229 /* Due to quantization, we will usually find that many of the input
230 * coefficients are zero, especially the AC terms. We can exploit this
231 * by short-circuiting the IDCT calculation for any row in which all
232 * the AC terms are zero. In that case each output is equal to the
233 * DC coefficient (with scale factor as needed).
234 * With typical images and quantization tables, half or more of the
235 * row DCT calculations can be simplified this way.
236 */
237
238 register uint8_t *idataptr = (uint8_t*)dataptr;
239
240 /* WARNING: we do the same permutation as MMX idct to simplify the
241 video core */
242 d0 = dataptr[0];
243 d2 = dataptr[1];
244 d4 = dataptr[2];
245 d6 = dataptr[3];
246 d1 = dataptr[4];
247 d3 = dataptr[5];
248 d5 = dataptr[6];
249 d7 = dataptr[7];
250
251 if ((d1 | d2 | d3 | d4 | d5 | d6 | d7) == 0) {
252 /* AC terms all zero */
253 if (d0) {
254 /* Compute a 32 bit value to assign. */
255 int16_t dcval = (int16_t) (d0 * (1 << PASS1_BITS));
256 register int v = (dcval & 0xffff) | ((dcval * (1 << 16)) & 0xffff0000);
257
258 AV_WN32A(&idataptr[ 0], v);
259 AV_WN32A(&idataptr[ 4], v);
260 AV_WN32A(&idataptr[ 8], v);
261 AV_WN32A(&idataptr[12], v);
262 }
263
264 dataptr += DCTSIZE; /* advance pointer to next row */
265 continue;
266 }
267
268 /* Even part: reverse the even part of the forward DCT. */
269 /* The rotator is sqrt(2)*c(-6). */
270 {
271 if (d6) {
272 if (d2) {
273 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
274 z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
275 tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
276 tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
277
278 tmp0 = (d0 + d4) * CONST_SCALE;
279 tmp1 = (d0 - d4) * CONST_SCALE;
280
281 tmp10 = tmp0 + tmp3;
282 tmp13 = tmp0 - tmp3;
283 tmp11 = tmp1 + tmp2;
284 tmp12 = tmp1 - tmp2;
285 } else {
286 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
287 tmp2 = MULTIPLY(-d6, FIX_1_306562965);
288 tmp3 = MULTIPLY(d6, FIX_0_541196100);
289
290 tmp0 = (d0 + d4) * CONST_SCALE;
291 tmp1 = (d0 - d4) * CONST_SCALE;
292
293 tmp10 = tmp0 + tmp3;
294 tmp13 = tmp0 - tmp3;
295 tmp11 = tmp1 + tmp2;
296 tmp12 = tmp1 - tmp2;
297 }
298 } else {
299 if (d2) {
300 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
301 tmp2 = MULTIPLY(d2, FIX_0_541196100);
302 tmp3 = MULTIPLY(d2, FIX_1_306562965);
303
304 tmp0 = (d0 + d4) * CONST_SCALE;
305 tmp1 = (d0 - d4) * CONST_SCALE;
306
307 tmp10 = tmp0 + tmp3;
308 tmp13 = tmp0 - tmp3;
309 tmp11 = tmp1 + tmp2;
310 tmp12 = tmp1 - tmp2;
311 } else {
312 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
313 tmp10 = tmp13 = (d0 + d4) * CONST_SCALE;
314 tmp11 = tmp12 = (d0 - d4) * CONST_SCALE;
315 }
316 }
317
318 /* Odd part per figure 8; the matrix is unitary and hence its
319 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
320 */
321
322 if (d7) {
323 if (d5) {
324 if (d3) {
325 if (d1) {
326 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
327 z1 = d7 + d1;
328 z2 = d5 + d3;
329 z3 = d7 + d3;
330 z4 = d5 + d1;
331 z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
332
333 tmp0 = MULTIPLY(d7, FIX_0_298631336);
334 tmp1 = MULTIPLY(d5, FIX_2_053119869);
335 tmp2 = MULTIPLY(d3, FIX_3_072711026);
336 tmp3 = MULTIPLY(d1, FIX_1_501321110);
337 z1 = MULTIPLY(-z1, FIX_0_899976223);
338 z2 = MULTIPLY(-z2, FIX_2_562915447);
339 z3 = MULTIPLY(-z3, FIX_1_961570560);
340 z4 = MULTIPLY(-z4, FIX_0_390180644);
341
342 z3 += z5;
343 z4 += z5;
344
345 tmp0 += z1 + z3;
346 tmp1 += z2 + z4;
347 tmp2 += z2 + z3;
348 tmp3 += z1 + z4;
349 } else {
350 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
351 z2 = d5 + d3;
352 z3 = d7 + d3;
353 z5 = MULTIPLY(z3 + d5, FIX_1_175875602);
354
355 tmp0 = MULTIPLY(d7, FIX_0_298631336);
356 tmp1 = MULTIPLY(d5, FIX_2_053119869);
357 tmp2 = MULTIPLY(d3, FIX_3_072711026);
358 z1 = MULTIPLY(-d7, FIX_0_899976223);
359 z2 = MULTIPLY(-z2, FIX_2_562915447);
360 z3 = MULTIPLY(-z3, FIX_1_961570560);
361 z4 = MULTIPLY(-d5, FIX_0_390180644);
362
363 z3 += z5;
364 z4 += z5;
365
366 tmp0 += z1 + z3;
367 tmp1 += z2 + z4;
368 tmp2 += z2 + z3;
369 tmp3 = z1 + z4;
370 }
371 } else {
372 if (d1) {
373 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
374 z1 = d7 + d1;
375 z4 = d5 + d1;
376 z5 = MULTIPLY(d7 + z4, FIX_1_175875602);
377
378 tmp0 = MULTIPLY(d7, FIX_0_298631336);
379 tmp1 = MULTIPLY(d5, FIX_2_053119869);
380 tmp3 = MULTIPLY(d1, FIX_1_501321110);
381 z1 = MULTIPLY(-z1, FIX_0_899976223);
382 z2 = MULTIPLY(-d5, FIX_2_562915447);
383 z3 = MULTIPLY(-d7, FIX_1_961570560);
384 z4 = MULTIPLY(-z4, FIX_0_390180644);
385
386 z3 += z5;
387 z4 += z5;
388
389 tmp0 += z1 + z3;
390 tmp1 += z2 + z4;
391 tmp2 = z2 + z3;
392 tmp3 += z1 + z4;
393 } else {
394 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
395 tmp0 = MULTIPLY(-d7, FIX_0_601344887);
396 z1 = MULTIPLY(-d7, FIX_0_899976223);
397 z3 = MULTIPLY(-d7, FIX_1_961570560);
398 tmp1 = MULTIPLY(-d5, FIX_0_509795579);
399 z2 = MULTIPLY(-d5, FIX_2_562915447);
400 z4 = MULTIPLY(-d5, FIX_0_390180644);
401 z5 = MULTIPLY(d5 + d7, FIX_1_175875602);
402
403 z3 += z5;
404 z4 += z5;
405
406 tmp0 += z3;
407 tmp1 += z4;
408 tmp2 = z2 + z3;
409 tmp3 = z1 + z4;
410 }
411 }
412 } else {
413 if (d3) {
414 if (d1) {
415 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
416 z1 = d7 + d1;
417 z3 = d7 + d3;
418 z5 = MULTIPLY(z3 + d1, FIX_1_175875602);
419
420 tmp0 = MULTIPLY(d7, FIX_0_298631336);
421 tmp2 = MULTIPLY(d3, FIX_3_072711026);
422 tmp3 = MULTIPLY(d1, FIX_1_501321110);
423 z1 = MULTIPLY(-z1, FIX_0_899976223);
424 z2 = MULTIPLY(-d3, FIX_2_562915447);
425 z3 = MULTIPLY(-z3, FIX_1_961570560);
426 z4 = MULTIPLY(-d1, FIX_0_390180644);
427
428 z3 += z5;
429 z4 += z5;
430
431 tmp0 += z1 + z3;
432 tmp1 = z2 + z4;
433 tmp2 += z2 + z3;
434 tmp3 += z1 + z4;
435 } else {
436 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
437 z3 = d7 + d3;
438
439 tmp0 = MULTIPLY(-d7, FIX_0_601344887);
440 z1 = MULTIPLY(-d7, FIX_0_899976223);
441 tmp2 = MULTIPLY(d3, FIX_0_509795579);
442 z2 = MULTIPLY(-d3, FIX_2_562915447);
443 z5 = MULTIPLY(z3, FIX_1_175875602);
444 z3 = MULTIPLY(-z3, FIX_0_785694958);
445
446 tmp0 += z3;
447 tmp1 = z2 + z5;
448 tmp2 += z3;
449 tmp3 = z1 + z5;
450 }
451 } else {
452 if (d1) {
453 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
454 z1 = d7 + d1;
455 z5 = MULTIPLY(z1, FIX_1_175875602);
456
457 z1 = MULTIPLY(z1, FIX_0_275899380);
458 z3 = MULTIPLY(-d7, FIX_1_961570560);
459 tmp0 = MULTIPLY(-d7, FIX_1_662939225);
460 z4 = MULTIPLY(-d1, FIX_0_390180644);
461 tmp3 = MULTIPLY(d1, FIX_1_111140466);
462
463 tmp0 += z1;
464 tmp1 = z4 + z5;
465 tmp2 = z3 + z5;
466 tmp3 += z1;
467 } else {
468 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
469 tmp0 = MULTIPLY(-d7, FIX_1_387039845);
470 tmp1 = MULTIPLY(d7, FIX_1_175875602);
471 tmp2 = MULTIPLY(-d7, FIX_0_785694958);
472 tmp3 = MULTIPLY(d7, FIX_0_275899380);
473 }
474 }
475 }
476 } else {
477 if (d5) {
478 if (d3) {
479 if (d1) {
480 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
481 z2 = d5 + d3;
482 z4 = d5 + d1;
483 z5 = MULTIPLY(d3 + z4, FIX_1_175875602);
484
485 tmp1 = MULTIPLY(d5, FIX_2_053119869);
486 tmp2 = MULTIPLY(d3, FIX_3_072711026);
487 tmp3 = MULTIPLY(d1, FIX_1_501321110);
488 z1 = MULTIPLY(-d1, FIX_0_899976223);
489 z2 = MULTIPLY(-z2, FIX_2_562915447);
490 z3 = MULTIPLY(-d3, FIX_1_961570560);
491 z4 = MULTIPLY(-z4, FIX_0_390180644);
492
493 z3 += z5;
494 z4 += z5;
495
496 tmp0 = z1 + z3;
497 tmp1 += z2 + z4;
498 tmp2 += z2 + z3;
499 tmp3 += z1 + z4;
500 } else {
501 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
502 z2 = d5 + d3;
503
504 z5 = MULTIPLY(z2, FIX_1_175875602);
505 tmp1 = MULTIPLY(d5, FIX_1_662939225);
506 z4 = MULTIPLY(-d5, FIX_0_390180644);
507 z2 = MULTIPLY(-z2, FIX_1_387039845);
508 tmp2 = MULTIPLY(d3, FIX_1_111140466);
509 z3 = MULTIPLY(-d3, FIX_1_961570560);
510
511 tmp0 = z3 + z5;
512 tmp1 += z2;
513 tmp2 += z2;
514 tmp3 = z4 + z5;
515 }
516 } else {
517 if (d1) {
518 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
519 z4 = d5 + d1;
520
521 z5 = MULTIPLY(z4, FIX_1_175875602);
522 z1 = MULTIPLY(-d1, FIX_0_899976223);
523 tmp3 = MULTIPLY(d1, FIX_0_601344887);
524 tmp1 = MULTIPLY(-d5, FIX_0_509795579);
525 z2 = MULTIPLY(-d5, FIX_2_562915447);
526 z4 = MULTIPLY(z4, FIX_0_785694958);
527
528 tmp0 = z1 + z5;
529 tmp1 += z4;
530 tmp2 = z2 + z5;
531 tmp3 += z4;
532 } else {
533 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
534 tmp0 = MULTIPLY(d5, FIX_1_175875602);
535 tmp1 = MULTIPLY(d5, FIX_0_275899380);
536 tmp2 = MULTIPLY(-d5, FIX_1_387039845);
537 tmp3 = MULTIPLY(d5, FIX_0_785694958);
538 }
539 }
540 } else {
541 if (d3) {
542 if (d1) {
543 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
544 z5 = d1 + d3;
545 tmp3 = MULTIPLY(d1, FIX_0_211164243);
546 tmp2 = MULTIPLY(-d3, FIX_1_451774981);
547 z1 = MULTIPLY(d1, FIX_1_061594337);
548 z2 = MULTIPLY(-d3, FIX_2_172734803);
549 z4 = MULTIPLY(z5, FIX_0_785694958);
550 z5 = MULTIPLY(z5, FIX_1_175875602);
551
552 tmp0 = z1 - z4;
553 tmp1 = z2 + z4;
554 tmp2 += z5;
555 tmp3 += z5;
556 } else {
557 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
558 tmp0 = MULTIPLY(-d3, FIX_0_785694958);
559 tmp1 = MULTIPLY(-d3, FIX_1_387039845);
560 tmp2 = MULTIPLY(-d3, FIX_0_275899380);
561 tmp3 = MULTIPLY(d3, FIX_1_175875602);
562 }
563 } else {
564 if (d1) {
565 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
566 tmp0 = MULTIPLY(d1, FIX_0_275899380);
567 tmp1 = MULTIPLY(d1, FIX_0_785694958);
568 tmp2 = MULTIPLY(d1, FIX_1_175875602);
569 tmp3 = MULTIPLY(d1, FIX_1_387039845);
570 } else {
571 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
572 tmp0 = tmp1 = tmp2 = tmp3 = 0;
573 }
574 }
575 }
576 }
577 }
578 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
579
580 dataptr[0] = (int16_t) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
581 dataptr[7] = (int16_t) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
582 dataptr[1] = (int16_t) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
583 dataptr[6] = (int16_t) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
584 dataptr[2] = (int16_t) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
585 dataptr[5] = (int16_t) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
586 dataptr[3] = (int16_t) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
587 dataptr[4] = (int16_t) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
588
589 dataptr += DCTSIZE; /* advance pointer to next row */
590 }
591
592 /* Pass 2: process columns. */
593 /* Note that we must descale the results by a factor of 8 == 2**3, */
594 /* and also undo the PASS1_BITS scaling. */
595
596 dataptr = data;
597 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
598 /* Columns of zeroes can be exploited in the same way as we did with rows.
599 * However, the row calculation has created many nonzero AC terms, so the
600 * simplification applies less often (typically 5% to 10% of the time).
601 * On machines with very fast multiplication, it's possible that the
602 * test takes more time than it's worth. In that case this section
603 * may be commented out.
604 */
605
606 d0 = dataptr[DCTSIZE*0];
607 d1 = dataptr[DCTSIZE*1];
608 d2 = dataptr[DCTSIZE*2];
609 d3 = dataptr[DCTSIZE*3];
610 d4 = dataptr[DCTSIZE*4];
611 d5 = dataptr[DCTSIZE*5];
612 d6 = dataptr[DCTSIZE*6];
613 d7 = dataptr[DCTSIZE*7];
614
615 /* Even part: reverse the even part of the forward DCT. */
616 /* The rotator is sqrt(2)*c(-6). */
617 if (d6) {
618 if (d2) {
619 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
620 z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
621 tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
622 tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
623
624 tmp0 = (d0 + d4) * CONST_SCALE;
625 tmp1 = (d0 - d4) * CONST_SCALE;
626
627 tmp10 = tmp0 + tmp3;
628 tmp13 = tmp0 - tmp3;
629 tmp11 = tmp1 + tmp2;
630 tmp12 = tmp1 - tmp2;
631 } else {
632 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
633 tmp2 = MULTIPLY(-d6, FIX_1_306562965);
634 tmp3 = MULTIPLY(d6, FIX_0_541196100);
635
636 tmp0 = (d0 + d4) * CONST_SCALE;
637 tmp1 = (d0 - d4) * CONST_SCALE;
638
639 tmp10 = tmp0 + tmp3;
640 tmp13 = tmp0 - tmp3;
641 tmp11 = tmp1 + tmp2;
642 tmp12 = tmp1 - tmp2;
643 }
644 } else {
645 if (d2) {
646 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
647 tmp2 = MULTIPLY(d2, FIX_0_541196100);
648 tmp3 = MULTIPLY(d2, FIX_1_306562965);
649
650 tmp0 = (d0 + d4) * CONST_SCALE;
651 tmp1 = (d0 - d4) * CONST_SCALE;
652
653 tmp10 = tmp0 + tmp3;
654 tmp13 = tmp0 - tmp3;
655 tmp11 = tmp1 + tmp2;
656 tmp12 = tmp1 - tmp2;
657 } else {
658 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
659 tmp10 = tmp13 = (d0 + d4) * CONST_SCALE;
660 tmp11 = tmp12 = (d0 - d4) * CONST_SCALE;
661 }
662 }
663
664 /* Odd part per figure 8; the matrix is unitary and hence its
665 * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
666 */
667 if (d7) {
668 if (d5) {
669 if (d3) {
670 if (d1) {
671 /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
672 z1 = d7 + d1;
673 z2 = d5 + d3;
674 z3 = d7 + d3;
675 z4 = d5 + d1;
676 z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
677
678 tmp0 = MULTIPLY(d7, FIX_0_298631336);
679 tmp1 = MULTIPLY(d5, FIX_2_053119869);
680 tmp2 = MULTIPLY(d3, FIX_3_072711026);
681 tmp3 = MULTIPLY(d1, FIX_1_501321110);
682 z1 = MULTIPLY(-z1, FIX_0_899976223);
683 z2 = MULTIPLY(-z2, FIX_2_562915447);
684 z3 = MULTIPLY(-z3, FIX_1_961570560);
685 z4 = MULTIPLY(-z4, FIX_0_390180644);
686
687 z3 += z5;
688 z4 += z5;
689
690 tmp0 += z1 + z3;
691 tmp1 += z2 + z4;
692 tmp2 += z2 + z3;
693 tmp3 += z1 + z4;
694 } else {
695 /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
696 z2 = d5 + d3;
697 z3 = d7 + d3;
698 z5 = MULTIPLY(z3 + d5, FIX_1_175875602);
699
700 tmp0 = MULTIPLY(d7, FIX_0_298631336);
701 tmp1 = MULTIPLY(d5, FIX_2_053119869);
702 tmp2 = MULTIPLY(d3, FIX_3_072711026);
703 z1 = MULTIPLY(-d7, FIX_0_899976223);
704 z2 = MULTIPLY(-z2, FIX_2_562915447);
705 z3 = MULTIPLY(-z3, FIX_1_961570560);
706 z4 = MULTIPLY(-d5, FIX_0_390180644);
707
708 z3 += z5;
709 z4 += z5;
710
711 tmp0 += z1 + z3;
712 tmp1 += z2 + z4;
713 tmp2 += z2 + z3;
714 tmp3 = z1 + z4;
715 }
716 } else {
717 if (d1) {
718 /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
719 z1 = d7 + d1;
720 z3 = d7;
721 z4 = d5 + d1;
722 z5 = MULTIPLY(z3 + z4, FIX_1_175875602);
723
724 tmp0 = MULTIPLY(d7, FIX_0_298631336);
725 tmp1 = MULTIPLY(d5, FIX_2_053119869);
726 tmp3 = MULTIPLY(d1, FIX_1_501321110);
727 z1 = MULTIPLY(-z1, FIX_0_899976223);
728 z2 = MULTIPLY(-d5, FIX_2_562915447);
729 z3 = MULTIPLY(-d7, FIX_1_961570560);
730 z4 = MULTIPLY(-z4, FIX_0_390180644);
731
732 z3 += z5;
733 z4 += z5;
734
735 tmp0 += z1 + z3;
736 tmp1 += z2 + z4;
737 tmp2 = z2 + z3;
738 tmp3 += z1 + z4;
739 } else {
740 /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
741 tmp0 = MULTIPLY(-d7, FIX_0_601344887);
742 z1 = MULTIPLY(-d7, FIX_0_899976223);
743 z3 = MULTIPLY(-d7, FIX_1_961570560);
744 tmp1 = MULTIPLY(-d5, FIX_0_509795579);
745 z2 = MULTIPLY(-d5, FIX_2_562915447);
746 z4 = MULTIPLY(-d5, FIX_0_390180644);
747 z5 = MULTIPLY(d5 + d7, FIX_1_175875602);
748
749 z3 += z5;
750 z4 += z5;
751
752 tmp0 += z3;
753 tmp1 += z4;
754 tmp2 = z2 + z3;
755 tmp3 = z1 + z4;
756 }
757 }
758 } else {
759 if (d3) {
760 if (d1) {
761 /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
762 z1 = d7 + d1;
763 z3 = d7 + d3;
764 z5 = MULTIPLY(z3 + d1, FIX_1_175875602);
765
766 tmp0 = MULTIPLY(d7, FIX_0_298631336);
767 tmp2 = MULTIPLY(d3, FIX_3_072711026);
768 tmp3 = MULTIPLY(d1, FIX_1_501321110);
769 z1 = MULTIPLY(-z1, FIX_0_899976223);
770 z2 = MULTIPLY(-d3, FIX_2_562915447);
771 z3 = MULTIPLY(-z3, FIX_1_961570560);
772 z4 = MULTIPLY(-d1, FIX_0_390180644);
773
774 z3 += z5;
775 z4 += z5;
776
777 tmp0 += z1 + z3;
778 tmp1 = z2 + z4;
779 tmp2 += z2 + z3;
780 tmp3 += z1 + z4;
781 } else {
782 /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
783 z3 = d7 + d3;
784
785 tmp0 = MULTIPLY(-d7, FIX_0_601344887);
786 z1 = MULTIPLY(-d7, FIX_0_899976223);
787 tmp2 = MULTIPLY(d3, FIX_0_509795579);
788 z2 = MULTIPLY(-d3, FIX_2_562915447);
789 z5 = MULTIPLY(z3, FIX_1_175875602);
790 z3 = MULTIPLY(-z3, FIX_0_785694958);
791
792 tmp0 += z3;
793 tmp1 = z2 + z5;
794 tmp2 += z3;
795 tmp3 = z1 + z5;
796 }
797 } else {
798 if (d1) {
799 /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
800 z1 = d7 + d1;
801 z5 = MULTIPLY(z1, FIX_1_175875602);
802
803 z1 = MULTIPLY(z1, FIX_0_275899380);
804 z3 = MULTIPLY(-d7, FIX_1_961570560);
805 tmp0 = MULTIPLY(-d7, FIX_1_662939225);
806 z4 = MULTIPLY(-d1, FIX_0_390180644);
807 tmp3 = MULTIPLY(d1, FIX_1_111140466);
808
809 tmp0 += z1;
810 tmp1 = z4 + z5;
811 tmp2 = z3 + z5;
812 tmp3 += z1;
813 } else {
814 /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
815 tmp0 = MULTIPLY(-d7, FIX_1_387039845);
816 tmp1 = MULTIPLY(d7, FIX_1_175875602);
817 tmp2 = MULTIPLY(-d7, FIX_0_785694958);
818 tmp3 = MULTIPLY(d7, FIX_0_275899380);
819 }
820 }
821 }
822 } else {
823 if (d5) {
824 if (d3) {
825 if (d1) {
826 /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
827 z2 = d5 + d3;
828 z4 = d5 + d1;
829 z5 = MULTIPLY(d3 + z4, FIX_1_175875602);
830
831 tmp1 = MULTIPLY(d5, FIX_2_053119869);
832 tmp2 = MULTIPLY(d3, FIX_3_072711026);
833 tmp3 = MULTIPLY(d1, FIX_1_501321110);
834 z1 = MULTIPLY(-d1, FIX_0_899976223);
835 z2 = MULTIPLY(-z2, FIX_2_562915447);
836 z3 = MULTIPLY(-d3, FIX_1_961570560);
837 z4 = MULTIPLY(-z4, FIX_0_390180644);
838
839 z3 += z5;
840 z4 += z5;
841
842 tmp0 = z1 + z3;
843 tmp1 += z2 + z4;
844 tmp2 += z2 + z3;
845 tmp3 += z1 + z4;
846 } else {
847 /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
848 z2 = d5 + d3;
849
850 z5 = MULTIPLY(z2, FIX_1_175875602);
851 tmp1 = MULTIPLY(d5, FIX_1_662939225);
852 z4 = MULTIPLY(-d5, FIX_0_390180644);
853 z2 = MULTIPLY(-z2, FIX_1_387039845);
854 tmp2 = MULTIPLY(d3, FIX_1_111140466);
855 z3 = MULTIPLY(-d3, FIX_1_961570560);
856
857 tmp0 = z3 + z5;
858 tmp1 += z2;
859 tmp2 += z2;
860 tmp3 = z4 + z5;
861 }
862 } else {
863 if (d1) {
864 /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
865 z4 = d5 + d1;
866
867 z5 = MULTIPLY(z4, FIX_1_175875602);
868 z1 = MULTIPLY(-d1, FIX_0_899976223);
869 tmp3 = MULTIPLY(d1, FIX_0_601344887);
870 tmp1 = MULTIPLY(-d5, FIX_0_509795579);
871 z2 = MULTIPLY(-d5, FIX_2_562915447);
872 z4 = MULTIPLY(z4, FIX_0_785694958);
873
874 tmp0 = z1 + z5;
875 tmp1 += z4;
876 tmp2 = z2 + z5;
877 tmp3 += z4;
878 } else {
879 /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
880 tmp0 = MULTIPLY(d5, FIX_1_175875602);
881 tmp1 = MULTIPLY(d5, FIX_0_275899380);
882 tmp2 = MULTIPLY(-d5, FIX_1_387039845);
883 tmp3 = MULTIPLY(d5, FIX_0_785694958);
884 }
885 }
886 } else {
887 if (d3) {
888 if (d1) {
889 /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
890 z5 = d1 + d3;
891 tmp3 = MULTIPLY(d1, FIX_0_211164243);
892 tmp2 = MULTIPLY(-d3, FIX_1_451774981);
893 z1 = MULTIPLY(d1, FIX_1_061594337);
894 z2 = MULTIPLY(-d3, FIX_2_172734803);
895 z4 = MULTIPLY(z5, FIX_0_785694958);
896 z5 = MULTIPLY(z5, FIX_1_175875602);
897
898 tmp0 = z1 - z4;
899 tmp1 = z2 + z4;
900 tmp2 += z5;
901 tmp3 += z5;
902 } else {
903 /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
904 tmp0 = MULTIPLY(-d3, FIX_0_785694958);
905 tmp1 = MULTIPLY(-d3, FIX_1_387039845);
906 tmp2 = MULTIPLY(-d3, FIX_0_275899380);
907 tmp3 = MULTIPLY(d3, FIX_1_175875602);
908 }
909 } else {
910 if (d1) {
911 /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
912 tmp0 = MULTIPLY(d1, FIX_0_275899380);
913 tmp1 = MULTIPLY(d1, FIX_0_785694958);
914 tmp2 = MULTIPLY(d1, FIX_1_175875602);
915 tmp3 = MULTIPLY(d1, FIX_1_387039845);
916 } else {
917 /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
918 tmp0 = tmp1 = tmp2 = tmp3 = 0;
919 }
920 }
921 }
922 }
923
924 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
925
926 dataptr[DCTSIZE*0] = (int16_t) DESCALE(tmp10 + tmp3,
927 CONST_BITS+PASS1_BITS+3);
928 dataptr[DCTSIZE*7] = (int16_t) DESCALE(tmp10 - tmp3,
929 CONST_BITS+PASS1_BITS+3);
930 dataptr[DCTSIZE*1] = (int16_t) DESCALE(tmp11 + tmp2,
931 CONST_BITS+PASS1_BITS+3);
932 dataptr[DCTSIZE*6] = (int16_t) DESCALE(tmp11 - tmp2,
933 CONST_BITS+PASS1_BITS+3);
934 dataptr[DCTSIZE*2] = (int16_t) DESCALE(tmp12 + tmp1,
935 CONST_BITS+PASS1_BITS+3);
936 dataptr[DCTSIZE*5] = (int16_t) DESCALE(tmp12 - tmp1,
937 CONST_BITS+PASS1_BITS+3);
938 dataptr[DCTSIZE*3] = (int16_t) DESCALE(tmp13 + tmp0,
939 CONST_BITS+PASS1_BITS+3);
940 dataptr[DCTSIZE*4] = (int16_t) DESCALE(tmp13 - tmp0,
941 CONST_BITS+PASS1_BITS+3);
942
943 dataptr++; /* advance pointer to next column */
944 }
945 }
946
947 #undef DCTSIZE
948 #define DCTSIZE 4
949 #define DCTSTRIDE 8
950
ff_j_rev_dct4(DCTBLOCK data)951 void ff_j_rev_dct4(DCTBLOCK data)
952 {
953 int32_t tmp0, tmp1, tmp2, tmp3;
954 int32_t tmp10, tmp11, tmp12, tmp13;
955 int32_t z1;
956 int32_t d0, d2, d4, d6;
957 register int16_t *dataptr;
958 int rowctr;
959
960 /* Pass 1: process rows. */
961 /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
962 /* furthermore, we scale the results by 2**PASS1_BITS. */
963
964 data[0] += 4;
965
966 dataptr = data;
967
968 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
969 /* Due to quantization, we will usually find that many of the input
970 * coefficients are zero, especially the AC terms. We can exploit this
971 * by short-circuiting the IDCT calculation for any row in which all
972 * the AC terms are zero. In that case each output is equal to the
973 * DC coefficient (with scale factor as needed).
974 * With typical images and quantization tables, half or more of the
975 * row DCT calculations can be simplified this way.
976 */
977
978 register uint8_t *idataptr = (uint8_t*)dataptr;
979
980 d0 = dataptr[0];
981 d2 = dataptr[1];
982 d4 = dataptr[2];
983 d6 = dataptr[3];
984
985 if ((d2 | d4 | d6) == 0) {
986 /* AC terms all zero */
987 if (d0) {
988 /* Compute a 32 bit value to assign. */
989 int16_t dcval = (int16_t) (d0 << PASS1_BITS);
990 register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
991
992 AV_WN32A(&idataptr[0], v);
993 AV_WN32A(&idataptr[4], v);
994 }
995
996 dataptr += DCTSTRIDE; /* advance pointer to next row */
997 continue;
998 }
999
1000 /* Even part: reverse the even part of the forward DCT. */
1001 /* The rotator is sqrt(2)*c(-6). */
1002 if (d6) {
1003 if (d2) {
1004 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
1005 z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1006 tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1007 tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1008
1009 tmp0 = (d0 + d4) << CONST_BITS;
1010 tmp1 = (d0 - d4) << CONST_BITS;
1011
1012 tmp10 = tmp0 + tmp3;
1013 tmp13 = tmp0 - tmp3;
1014 tmp11 = tmp1 + tmp2;
1015 tmp12 = tmp1 - tmp2;
1016 } else {
1017 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
1018 tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1019 tmp3 = MULTIPLY(d6, FIX_0_541196100);
1020
1021 tmp0 = (d0 + d4) << CONST_BITS;
1022 tmp1 = (d0 - d4) << CONST_BITS;
1023
1024 tmp10 = tmp0 + tmp3;
1025 tmp13 = tmp0 - tmp3;
1026 tmp11 = tmp1 + tmp2;
1027 tmp12 = tmp1 - tmp2;
1028 }
1029 } else {
1030 if (d2) {
1031 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
1032 tmp2 = MULTIPLY(d2, FIX_0_541196100);
1033 tmp3 = MULTIPLY(d2, FIX_1_306562965);
1034
1035 tmp0 = (d0 + d4) << CONST_BITS;
1036 tmp1 = (d0 - d4) << CONST_BITS;
1037
1038 tmp10 = tmp0 + tmp3;
1039 tmp13 = tmp0 - tmp3;
1040 tmp11 = tmp1 + tmp2;
1041 tmp12 = tmp1 - tmp2;
1042 } else {
1043 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
1044 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
1045 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
1046 }
1047 }
1048
1049 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1050
1051 dataptr[0] = (int16_t) DESCALE(tmp10, CONST_BITS-PASS1_BITS);
1052 dataptr[1] = (int16_t) DESCALE(tmp11, CONST_BITS-PASS1_BITS);
1053 dataptr[2] = (int16_t) DESCALE(tmp12, CONST_BITS-PASS1_BITS);
1054 dataptr[3] = (int16_t) DESCALE(tmp13, CONST_BITS-PASS1_BITS);
1055
1056 dataptr += DCTSTRIDE; /* advance pointer to next row */
1057 }
1058
1059 /* Pass 2: process columns. */
1060 /* Note that we must descale the results by a factor of 8 == 2**3, */
1061 /* and also undo the PASS1_BITS scaling. */
1062
1063 dataptr = data;
1064 for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
1065 /* Columns of zeroes can be exploited in the same way as we did with rows.
1066 * However, the row calculation has created many nonzero AC terms, so the
1067 * simplification applies less often (typically 5% to 10% of the time).
1068 * On machines with very fast multiplication, it's possible that the
1069 * test takes more time than it's worth. In that case this section
1070 * may be commented out.
1071 */
1072
1073 d0 = dataptr[DCTSTRIDE*0];
1074 d2 = dataptr[DCTSTRIDE*1];
1075 d4 = dataptr[DCTSTRIDE*2];
1076 d6 = dataptr[DCTSTRIDE*3];
1077
1078 /* Even part: reverse the even part of the forward DCT. */
1079 /* The rotator is sqrt(2)*c(-6). */
1080 if (d6) {
1081 if (d2) {
1082 /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
1083 z1 = MULTIPLY(d2 + d6, FIX_0_541196100);
1084 tmp2 = z1 + MULTIPLY(-d6, FIX_1_847759065);
1085 tmp3 = z1 + MULTIPLY(d2, FIX_0_765366865);
1086
1087 tmp0 = (d0 + d4) << CONST_BITS;
1088 tmp1 = (d0 - d4) << CONST_BITS;
1089
1090 tmp10 = tmp0 + tmp3;
1091 tmp13 = tmp0 - tmp3;
1092 tmp11 = tmp1 + tmp2;
1093 tmp12 = tmp1 - tmp2;
1094 } else {
1095 /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
1096 tmp2 = MULTIPLY(-d6, FIX_1_306562965);
1097 tmp3 = MULTIPLY(d6, FIX_0_541196100);
1098
1099 tmp0 = (d0 + d4) << CONST_BITS;
1100 tmp1 = (d0 - d4) << CONST_BITS;
1101
1102 tmp10 = tmp0 + tmp3;
1103 tmp13 = tmp0 - tmp3;
1104 tmp11 = tmp1 + tmp2;
1105 tmp12 = tmp1 - tmp2;
1106 }
1107 } else {
1108 if (d2) {
1109 /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
1110 tmp2 = MULTIPLY(d2, FIX_0_541196100);
1111 tmp3 = MULTIPLY(d2, FIX_1_306562965);
1112
1113 tmp0 = (d0 + d4) << CONST_BITS;
1114 tmp1 = (d0 - d4) << CONST_BITS;
1115
1116 tmp10 = tmp0 + tmp3;
1117 tmp13 = tmp0 - tmp3;
1118 tmp11 = tmp1 + tmp2;
1119 tmp12 = tmp1 - tmp2;
1120 } else {
1121 /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
1122 tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
1123 tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
1124 }
1125 }
1126
1127 /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
1128
1129 dataptr[DCTSTRIDE*0] = tmp10 >> (CONST_BITS+PASS1_BITS+3);
1130 dataptr[DCTSTRIDE*1] = tmp11 >> (CONST_BITS+PASS1_BITS+3);
1131 dataptr[DCTSTRIDE*2] = tmp12 >> (CONST_BITS+PASS1_BITS+3);
1132 dataptr[DCTSTRIDE*3] = tmp13 >> (CONST_BITS+PASS1_BITS+3);
1133
1134 dataptr++; /* advance pointer to next column */
1135 }
1136 }
1137
ff_j_rev_dct2(DCTBLOCK data)1138 void ff_j_rev_dct2(DCTBLOCK data){
1139 int d00, d01, d10, d11;
1140
1141 data[0] += 4;
1142 d00 = data[0+0*DCTSTRIDE] + data[1+0*DCTSTRIDE];
1143 d01 = data[0+0*DCTSTRIDE] - data[1+0*DCTSTRIDE];
1144 d10 = data[0+1*DCTSTRIDE] + data[1+1*DCTSTRIDE];
1145 d11 = data[0+1*DCTSTRIDE] - data[1+1*DCTSTRIDE];
1146
1147 data[0+0*DCTSTRIDE]= (d00 + d10)>>3;
1148 data[1+0*DCTSTRIDE]= (d01 + d11)>>3;
1149 data[0+1*DCTSTRIDE]= (d00 - d10)>>3;
1150 data[1+1*DCTSTRIDE]= (d01 - d11)>>3;
1151 }
1152
ff_j_rev_dct1(DCTBLOCK data)1153 void ff_j_rev_dct1(DCTBLOCK data){
1154 data[0] = (data[0] + 4)>>3;
1155 }
1156
1157 #undef FIX
1158 #undef CONST_BITS
1159
ff_jref_idct_put(uint8_t * dest,ptrdiff_t line_size,int16_t * block)1160 void ff_jref_idct_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
1161 {
1162 ff_j_rev_dct(block);
1163 ff_put_pixels_clamped_c(block, dest, line_size);
1164 }
1165
ff_jref_idct_add(uint8_t * dest,ptrdiff_t line_size,int16_t * block)1166 void ff_jref_idct_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
1167 {
1168 ff_j_rev_dct(block);
1169 ff_add_pixels_clamped_c(block, dest, line_size);
1170 }
1171