some updates to the Linux build system - obtained a core binary and all required...
[xonotic/netradiant.git] / libs / jpeg6 / jfdctflt.cpp
1 /*\r
2 \r
3  * jfdctflt.c\r
4 \r
5  *\r
6 \r
7  * Copyright (C) 1994, Thomas G. Lane.\r
8 \r
9  * This file is part of the Independent JPEG Group's software.\r
10 \r
11  * For conditions of distribution and use, see the accompanying README file.\r
12 \r
13  *\r
14 \r
15  * This file contains a floating-point implementation of the\r
16 \r
17  * forward DCT (Discrete Cosine Transform).\r
18 \r
19  *\r
20 \r
21  * This implementation should be more accurate than either of the integer\r
22 \r
23  * DCT implementations.  However, it may not give the same results on all\r
24 \r
25  * machines because of differences in roundoff behavior.  Speed will depend\r
26 \r
27  * on the hardware's floating point capacity.\r
28 \r
29  *\r
30 \r
31  * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT\r
32 \r
33  * on each column.  Direct algorithms are also available, but they are\r
34 \r
35  * much more complex and seem not to be any faster when reduced to code.\r
36 \r
37  *\r
38 \r
39  * This implementation is based on Arai, Agui, and Nakajima's algorithm for\r
40 \r
41  * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in\r
42 \r
43  * Japanese, but the algorithm is described in the Pennebaker & Mitchell\r
44 \r
45  * JPEG textbook (see REFERENCES section in file README).  The following code\r
46 \r
47  * is based directly on figure 4-8 in P&M.\r
48 \r
49  * While an 8-point DCT cannot be done in less than 11 multiplies, it is\r
50 \r
51  * possible to arrange the computation so that many of the multiplies are\r
52 \r
53  * simple scalings of the final outputs.  These multiplies can then be\r
54 \r
55  * folded into the multiplications or divisions by the JPEG quantization\r
56 \r
57  * table entries.  The AA&N method leaves only 5 multiplies and 29 adds\r
58 \r
59  * to be done in the DCT itself.\r
60 \r
61  * The primary disadvantage of this method is that with a fixed-point\r
62 \r
63  * implementation, accuracy is lost due to imprecise representation of the\r
64 \r
65  * scaled quantization values.  However, that problem does not arise if\r
66 \r
67  * we use floating point arithmetic.\r
68 \r
69  */\r
70 \r
71 \r
72 \r
73 #define JPEG_INTERNALS\r
74 \r
75 #include "jinclude.h"\r
76 \r
77 #include "radiant_jpeglib.h"\r
78 \r
79 #include "jdct.h"               /* Private declarations for DCT subsystem */\r
80 \r
81 \r
82 \r
83 #ifdef DCT_FLOAT_SUPPORTED\r
84 \r
85 \r
86 \r
87 \r
88 \r
89 /*\r
90 \r
91  * This module is specialized to the case DCTSIZE = 8.\r
92 \r
93  */\r
94 \r
95 \r
96 \r
97 #if DCTSIZE != 8\r
98 \r
99   Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */\r
100 \r
101 #endif\r
102 \r
103 \r
104 \r
105 \r
106 \r
107 /*\r
108 \r
109  * Perform the forward DCT on one block of samples.\r
110 \r
111  */\r
112 \r
113 \r
114 \r
115 GLOBAL void\r
116 \r
117 jpeg_fdct_float (FAST_FLOAT * data)\r
118 \r
119 {\r
120 \r
121   FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;\r
122 \r
123   FAST_FLOAT tmp10, tmp11, tmp12, tmp13;\r
124 \r
125   FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;\r
126 \r
127   FAST_FLOAT *dataptr;\r
128 \r
129   int ctr;\r
130 \r
131 \r
132 \r
133   /* Pass 1: process rows. */\r
134 \r
135 \r
136 \r
137   dataptr = data;\r
138 \r
139   for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {\r
140 \r
141     tmp0 = dataptr[0] + dataptr[7];\r
142 \r
143     tmp7 = dataptr[0] - dataptr[7];\r
144 \r
145     tmp1 = dataptr[1] + dataptr[6];\r
146 \r
147     tmp6 = dataptr[1] - dataptr[6];\r
148 \r
149     tmp2 = dataptr[2] + dataptr[5];\r
150 \r
151     tmp5 = dataptr[2] - dataptr[5];\r
152 \r
153     tmp3 = dataptr[3] + dataptr[4];\r
154 \r
155     tmp4 = dataptr[3] - dataptr[4];\r
156 \r
157     \r
158 \r
159     /* Even part */\r
160 \r
161     \r
162 \r
163     tmp10 = tmp0 + tmp3;        /* phase 2 */\r
164 \r
165     tmp13 = tmp0 - tmp3;\r
166 \r
167     tmp11 = tmp1 + tmp2;\r
168 \r
169     tmp12 = tmp1 - tmp2;\r
170 \r
171     \r
172 \r
173     dataptr[0] = tmp10 + tmp11; /* phase 3 */\r
174 \r
175     dataptr[4] = tmp10 - tmp11;\r
176 \r
177     \r
178 \r
179     z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */\r
180 \r
181     dataptr[2] = tmp13 + z1;    /* phase 5 */\r
182 \r
183     dataptr[6] = tmp13 - z1;\r
184 \r
185     \r
186 \r
187     /* Odd part */\r
188 \r
189 \r
190 \r
191     tmp10 = tmp4 + tmp5;        /* phase 2 */\r
192 \r
193     tmp11 = tmp5 + tmp6;\r
194 \r
195     tmp12 = tmp6 + tmp7;\r
196 \r
197 \r
198 \r
199     /* The rotator is modified from fig 4-8 to avoid extra negations. */\r
200 \r
201     z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */\r
202 \r
203     z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */\r
204 \r
205     z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */\r
206 \r
207     z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */\r
208 \r
209 \r
210 \r
211     z11 = tmp7 + z3;            /* phase 5 */\r
212 \r
213     z13 = tmp7 - z3;\r
214 \r
215 \r
216 \r
217     dataptr[5] = z13 + z2;      /* phase 6 */\r
218 \r
219     dataptr[3] = z13 - z2;\r
220 \r
221     dataptr[1] = z11 + z4;\r
222 \r
223     dataptr[7] = z11 - z4;\r
224 \r
225 \r
226 \r
227     dataptr += DCTSIZE;         /* advance pointer to next row */\r
228 \r
229   }\r
230 \r
231 \r
232 \r
233   /* Pass 2: process columns. */\r
234 \r
235 \r
236 \r
237   dataptr = data;\r
238 \r
239   for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {\r
240 \r
241     tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];\r
242 \r
243     tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];\r
244 \r
245     tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];\r
246 \r
247     tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];\r
248 \r
249     tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];\r
250 \r
251     tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];\r
252 \r
253     tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];\r
254 \r
255     tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];\r
256 \r
257     \r
258 \r
259     /* Even part */\r
260 \r
261     \r
262 \r
263     tmp10 = tmp0 + tmp3;        /* phase 2 */\r
264 \r
265     tmp13 = tmp0 - tmp3;\r
266 \r
267     tmp11 = tmp1 + tmp2;\r
268 \r
269     tmp12 = tmp1 - tmp2;\r
270 \r
271     \r
272 \r
273     dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */\r
274 \r
275     dataptr[DCTSIZE*4] = tmp10 - tmp11;\r
276 \r
277     \r
278 \r
279     z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */\r
280 \r
281     dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */\r
282 \r
283     dataptr[DCTSIZE*6] = tmp13 - z1;\r
284 \r
285     \r
286 \r
287     /* Odd part */\r
288 \r
289 \r
290 \r
291     tmp10 = tmp4 + tmp5;        /* phase 2 */\r
292 \r
293     tmp11 = tmp5 + tmp6;\r
294 \r
295     tmp12 = tmp6 + tmp7;\r
296 \r
297 \r
298 \r
299     /* The rotator is modified from fig 4-8 to avoid extra negations. */\r
300 \r
301     z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */\r
302 \r
303     z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */\r
304 \r
305     z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */\r
306 \r
307     z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */\r
308 \r
309 \r
310 \r
311     z11 = tmp7 + z3;            /* phase 5 */\r
312 \r
313     z13 = tmp7 - z3;\r
314 \r
315 \r
316 \r
317     dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */\r
318 \r
319     dataptr[DCTSIZE*3] = z13 - z2;\r
320 \r
321     dataptr[DCTSIZE*1] = z11 + z4;\r
322 \r
323     dataptr[DCTSIZE*7] = z11 - z4;\r
324 \r
325 \r
326 \r
327     dataptr++;                  /* advance pointer to next column */\r
328 \r
329   }\r
330 \r
331 }\r
332 \r
333 \r
334 \r
335 #endif /* DCT_FLOAT_SUPPORTED */\r
336 \r