OLD | NEW |
1 /* | 1 /* |
2 * jfdctfst.c | 2 * jfdctfst.c |
3 * | 3 * |
| 4 * This file was part of the Independent JPEG Group's software: |
4 * Copyright (C) 1994-1996, Thomas G. Lane. | 5 * Copyright (C) 1994-1996, Thomas G. Lane. |
5 * This file is part of the Independent JPEG Group's software. | 6 * libjpeg-turbo Modifications: |
6 * For conditions of distribution and use, see the accompanying README file. | 7 * Copyright (C) 2015, D. R. Commander |
| 8 * For conditions of distribution and use, see the accompanying README.ijg |
| 9 * file. |
7 * | 10 * |
8 * This file contains a fast, not so accurate integer implementation of the | 11 * This file contains a fast, not so accurate integer implementation of the |
9 * forward DCT (Discrete Cosine Transform). | 12 * forward DCT (Discrete Cosine Transform). |
10 * | 13 * |
11 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT | 14 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT |
12 * on each column. Direct algorithms are also available, but they are | 15 * on each column. Direct algorithms are also available, but they are |
13 * much more complex and seem not to be any faster when reduced to code. | 16 * much more complex and seem not to be any faster when reduced to code. |
14 * | 17 * |
15 * This implementation is based on Arai, Agui, and Nakajima's algorithm for | 18 * This implementation is based on Arai, Agui, and Nakajima's algorithm for |
16 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in | 19 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in |
17 * Japanese, but the algorithm is described in the Pennebaker & Mitchell | 20 * Japanese, but the algorithm is described in the Pennebaker & Mitchell |
18 * JPEG textbook (see REFERENCES section in file README). The following code | 21 * JPEG textbook (see REFERENCES section in file README.ijg). The following |
19 * is based directly on figure 4-8 in P&M. | 22 * code is based directly on figure 4-8 in P&M. |
20 * While an 8-point DCT cannot be done in less than 11 multiplies, it is | 23 * While an 8-point DCT cannot be done in less than 11 multiplies, it is |
21 * possible to arrange the computation so that many of the multiplies are | 24 * possible to arrange the computation so that many of the multiplies are |
22 * simple scalings of the final outputs. These multiplies can then be | 25 * simple scalings of the final outputs. These multiplies can then be |
23 * folded into the multiplications or divisions by the JPEG quantization | 26 * folded into the multiplications or divisions by the JPEG quantization |
24 * table entries. The AA&N method leaves only 5 multiplies and 29 adds | 27 * table entries. The AA&N method leaves only 5 multiplies and 29 adds |
25 * to be done in the DCT itself. | 28 * to be done in the DCT itself. |
26 * The primary disadvantage of this method is that with fixed-point math, | 29 * The primary disadvantage of this method is that with fixed-point math, |
27 * accuracy is lost due to imprecise representation of the scaled | 30 * accuracy is lost due to imprecise representation of the scaled |
28 * quantization values. The smaller the quantization table entry, the less | 31 * quantization values. The smaller the quantization table entry, the less |
29 * precise the scaled value, so this implementation does worse with high- | 32 * precise the scaled value, so this implementation does worse with high- |
30 * quality-setting files than with low-quality ones. | 33 * quality-setting files than with low-quality ones. |
31 */ | 34 */ |
32 | 35 |
33 #define JPEG_INTERNALS | 36 #define JPEG_INTERNALS |
34 #include "jinclude.h" | 37 #include "jinclude.h" |
35 #include "jpeglib.h" | 38 #include "jpeglib.h" |
36 #include "jdct.h"» » /* Private declarations for DCT subsystem */ | 39 #include "jdct.h" /* Private declarations for DCT subsystem */ |
37 | 40 |
38 #ifdef DCT_IFAST_SUPPORTED | 41 #ifdef DCT_IFAST_SUPPORTED |
39 | 42 |
40 | 43 |
41 /* | 44 /* |
42 * This module is specialized to the case DCTSIZE = 8. | 45 * This module is specialized to the case DCTSIZE = 8. |
43 */ | 46 */ |
44 | 47 |
45 #if DCTSIZE != 8 | 48 #if DCTSIZE != 8 |
46 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ | 49 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ |
(...skipping 22 matching lines...) Expand all Loading... |
69 | 72 |
70 | 73 |
71 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus | 74 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus |
72 * causing a lot of useless floating-point operations at run time. | 75 * causing a lot of useless floating-point operations at run time. |
73 * To get around this we use the following pre-calculated constants. | 76 * To get around this we use the following pre-calculated constants. |
74 * If you change CONST_BITS you may want to add appropriate values. | 77 * If you change CONST_BITS you may want to add appropriate values. |
75 * (With a reasonable C compiler, you can just rely on the FIX() macro...) | 78 * (With a reasonable C compiler, you can just rely on the FIX() macro...) |
76 */ | 79 */ |
77 | 80 |
78 #if CONST_BITS == 8 | 81 #if CONST_BITS == 8 |
79 #define FIX_0_382683433 ((INT32) 98)»» /* FIX(0.382683433) */ | 82 #define FIX_0_382683433 ((JLONG) 98) /* FIX(0.382683433) */ |
80 #define FIX_0_541196100 ((INT32) 139)»» /* FIX(0.541196100) */ | 83 #define FIX_0_541196100 ((JLONG) 139) /* FIX(0.541196100) */ |
81 #define FIX_0_707106781 ((INT32) 181)»» /* FIX(0.707106781) */ | 84 #define FIX_0_707106781 ((JLONG) 181) /* FIX(0.707106781) */ |
82 #define FIX_1_306562965 ((INT32) 334)»» /* FIX(1.306562965) */ | 85 #define FIX_1_306562965 ((JLONG) 334) /* FIX(1.306562965) */ |
83 #else | 86 #else |
84 #define FIX_0_382683433 FIX(0.382683433) | 87 #define FIX_0_382683433 FIX(0.382683433) |
85 #define FIX_0_541196100 FIX(0.541196100) | 88 #define FIX_0_541196100 FIX(0.541196100) |
86 #define FIX_0_707106781 FIX(0.707106781) | 89 #define FIX_0_707106781 FIX(0.707106781) |
87 #define FIX_1_306562965 FIX(1.306562965) | 90 #define FIX_1_306562965 FIX(1.306562965) |
88 #endif | 91 #endif |
89 | 92 |
90 | 93 |
91 /* We can gain a little more speed, with a further compromise in accuracy, | 94 /* We can gain a little more speed, with a further compromise in accuracy, |
92 * by omitting the addition in a descaling shift. This yields an incorrectly | 95 * by omitting the addition in a descaling shift. This yields an incorrectly |
93 * rounded result half the time... | 96 * rounded result half the time... |
94 */ | 97 */ |
95 | 98 |
96 #ifndef USE_ACCURATE_ROUNDING | 99 #ifndef USE_ACCURATE_ROUNDING |
97 #undef DESCALE | 100 #undef DESCALE |
98 #define DESCALE(x,n) RIGHT_SHIFT(x, n) | 101 #define DESCALE(x,n) RIGHT_SHIFT(x, n) |
99 #endif | 102 #endif |
100 | 103 |
101 | 104 |
102 /* Multiply a DCTELEM variable by an INT32 constant, and immediately | 105 /* Multiply a DCTELEM variable by an JLONG constant, and immediately |
103 * descale to yield a DCTELEM result. | 106 * descale to yield a DCTELEM result. |
104 */ | 107 */ |
105 | 108 |
106 #define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) | 109 #define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) |
107 | 110 |
108 | 111 |
109 /* | 112 /* |
110 * Perform the forward DCT on one block of samples. | 113 * Perform the forward DCT on one block of samples. |
111 */ | 114 */ |
112 | 115 |
113 GLOBAL(void) | 116 GLOBAL(void) |
114 jpeg_fdct_ifast (DCTELEM * data) | 117 jpeg_fdct_ifast (DCTELEM *data) |
115 { | 118 { |
116 DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; | 119 DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; |
117 DCTELEM tmp10, tmp11, tmp12, tmp13; | 120 DCTELEM tmp10, tmp11, tmp12, tmp13; |
118 DCTELEM z1, z2, z3, z4, z5, z11, z13; | 121 DCTELEM z1, z2, z3, z4, z5, z11, z13; |
119 DCTELEM *dataptr; | 122 DCTELEM *dataptr; |
120 int ctr; | 123 int ctr; |
121 SHIFT_TEMPS | 124 SHIFT_TEMPS |
122 | 125 |
123 /* Pass 1: process rows. */ | 126 /* Pass 1: process rows. */ |
124 | 127 |
125 dataptr = data; | 128 dataptr = data; |
126 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | 129 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { |
127 tmp0 = dataptr[0] + dataptr[7]; | 130 tmp0 = dataptr[0] + dataptr[7]; |
128 tmp7 = dataptr[0] - dataptr[7]; | 131 tmp7 = dataptr[0] - dataptr[7]; |
129 tmp1 = dataptr[1] + dataptr[6]; | 132 tmp1 = dataptr[1] + dataptr[6]; |
130 tmp6 = dataptr[1] - dataptr[6]; | 133 tmp6 = dataptr[1] - dataptr[6]; |
131 tmp2 = dataptr[2] + dataptr[5]; | 134 tmp2 = dataptr[2] + dataptr[5]; |
132 tmp5 = dataptr[2] - dataptr[5]; | 135 tmp5 = dataptr[2] - dataptr[5]; |
133 tmp3 = dataptr[3] + dataptr[4]; | 136 tmp3 = dataptr[3] + dataptr[4]; |
134 tmp4 = dataptr[3] - dataptr[4]; | 137 tmp4 = dataptr[3] - dataptr[4]; |
135 | 138 |
136 /* Even part */ | 139 /* Even part */ |
137 | 140 |
138 tmp10 = tmp0 + tmp3;» /* phase 2 */ | 141 tmp10 = tmp0 + tmp3; /* phase 2 */ |
139 tmp13 = tmp0 - tmp3; | 142 tmp13 = tmp0 - tmp3; |
140 tmp11 = tmp1 + tmp2; | 143 tmp11 = tmp1 + tmp2; |
141 tmp12 = tmp1 - tmp2; | 144 tmp12 = tmp1 - tmp2; |
142 | 145 |
143 dataptr[0] = tmp10 + tmp11; /* phase 3 */ | 146 dataptr[0] = tmp10 + tmp11; /* phase 3 */ |
144 dataptr[4] = tmp10 - tmp11; | 147 dataptr[4] = tmp10 - tmp11; |
145 | 148 |
146 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ | 149 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ |
147 dataptr[2] = tmp13 + z1;» /* phase 5 */ | 150 dataptr[2] = tmp13 + z1; /* phase 5 */ |
148 dataptr[6] = tmp13 - z1; | 151 dataptr[6] = tmp13 - z1; |
149 | 152 |
150 /* Odd part */ | 153 /* Odd part */ |
151 | 154 |
152 tmp10 = tmp4 + tmp5;» /* phase 2 */ | 155 tmp10 = tmp4 + tmp5; /* phase 2 */ |
153 tmp11 = tmp5 + tmp6; | 156 tmp11 = tmp5 + tmp6; |
154 tmp12 = tmp6 + tmp7; | 157 tmp12 = tmp6 + tmp7; |
155 | 158 |
156 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | 159 /* The rotator is modified from fig 4-8 to avoid extra negations. */ |
157 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ | 160 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ |
158 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ | 161 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ |
159 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ | 162 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ |
160 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ | 163 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ |
161 | 164 |
162 z11 = tmp7 + z3;» » /* phase 5 */ | 165 z11 = tmp7 + z3; /* phase 5 */ |
163 z13 = tmp7 - z3; | 166 z13 = tmp7 - z3; |
164 | 167 |
165 dataptr[5] = z13 + z2;» /* phase 6 */ | 168 dataptr[5] = z13 + z2; /* phase 6 */ |
166 dataptr[3] = z13 - z2; | 169 dataptr[3] = z13 - z2; |
167 dataptr[1] = z11 + z4; | 170 dataptr[1] = z11 + z4; |
168 dataptr[7] = z11 - z4; | 171 dataptr[7] = z11 - z4; |
169 | 172 |
170 dataptr += DCTSIZE;»» /* advance pointer to next row */ | 173 dataptr += DCTSIZE; /* advance pointer to next row */ |
171 } | 174 } |
172 | 175 |
173 /* Pass 2: process columns. */ | 176 /* Pass 2: process columns. */ |
174 | 177 |
175 dataptr = data; | 178 dataptr = data; |
176 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | 179 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { |
177 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; | 180 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; |
178 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; | 181 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; |
179 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; | 182 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; |
180 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; | 183 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; |
181 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; | 184 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; |
182 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; | 185 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; |
183 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; | 186 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; |
184 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; | 187 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; |
185 | 188 |
186 /* Even part */ | 189 /* Even part */ |
187 | 190 |
188 tmp10 = tmp0 + tmp3;» /* phase 2 */ | 191 tmp10 = tmp0 + tmp3; /* phase 2 */ |
189 tmp13 = tmp0 - tmp3; | 192 tmp13 = tmp0 - tmp3; |
190 tmp11 = tmp1 + tmp2; | 193 tmp11 = tmp1 + tmp2; |
191 tmp12 = tmp1 - tmp2; | 194 tmp12 = tmp1 - tmp2; |
192 | 195 |
193 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ | 196 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ |
194 dataptr[DCTSIZE*4] = tmp10 - tmp11; | 197 dataptr[DCTSIZE*4] = tmp10 - tmp11; |
195 | 198 |
196 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ | 199 z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ |
197 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ | 200 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ |
198 dataptr[DCTSIZE*6] = tmp13 - z1; | 201 dataptr[DCTSIZE*6] = tmp13 - z1; |
199 | 202 |
200 /* Odd part */ | 203 /* Odd part */ |
201 | 204 |
202 tmp10 = tmp4 + tmp5;» /* phase 2 */ | 205 tmp10 = tmp4 + tmp5; /* phase 2 */ |
203 tmp11 = tmp5 + tmp6; | 206 tmp11 = tmp5 + tmp6; |
204 tmp12 = tmp6 + tmp7; | 207 tmp12 = tmp6 + tmp7; |
205 | 208 |
206 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | 209 /* The rotator is modified from fig 4-8 to avoid extra negations. */ |
207 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ | 210 z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ |
208 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ | 211 z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ |
209 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ | 212 z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ |
210 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ | 213 z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ |
211 | 214 |
212 z11 = tmp7 + z3;» » /* phase 5 */ | 215 z11 = tmp7 + z3; /* phase 5 */ |
213 z13 = tmp7 - z3; | 216 z13 = tmp7 - z3; |
214 | 217 |
215 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ | 218 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ |
216 dataptr[DCTSIZE*3] = z13 - z2; | 219 dataptr[DCTSIZE*3] = z13 - z2; |
217 dataptr[DCTSIZE*1] = z11 + z4; | 220 dataptr[DCTSIZE*1] = z11 + z4; |
218 dataptr[DCTSIZE*7] = z11 - z4; | 221 dataptr[DCTSIZE*7] = z11 - z4; |
219 | 222 |
220 dataptr++;» » » /* advance pointer to next column */ | 223 dataptr++; /* advance pointer to next column */ |
221 } | 224 } |
222 } | 225 } |
223 | 226 |
224 #endif /* DCT_IFAST_SUPPORTED */ | 227 #endif /* DCT_IFAST_SUPPORTED */ |
OLD | NEW |