OLD | NEW |
1 /* | 1 /* |
2 * jfdctflt.c | 2 * jfdctflt.c |
3 * | 3 * |
4 * Copyright (C) 1994-1996, Thomas G. Lane. | 4 * Copyright (C) 1994-1996, Thomas G. Lane. |
5 * This file is part of the Independent JPEG Group's software. | 5 * This file is part of the Independent JPEG Group's software. |
6 * For conditions of distribution and use, see the accompanying README file. | 6 * For conditions of distribution and use, see the accompanying README.ijg |
| 7 * file. |
7 * | 8 * |
8 * This file contains a floating-point implementation of the | 9 * This file contains a floating-point implementation of the |
9 * forward DCT (Discrete Cosine Transform). | 10 * forward DCT (Discrete Cosine Transform). |
10 * | 11 * |
11 * This implementation should be more accurate than either of the integer | 12 * This implementation should be more accurate than either of the integer |
12 * DCT implementations. However, it may not give the same results on all | 13 * DCT implementations. However, it may not give the same results on all |
13 * machines because of differences in roundoff behavior. Speed will depend | 14 * machines because of differences in roundoff behavior. Speed will depend |
14 * on the hardware's floating point capacity. | 15 * on the hardware's floating point capacity. |
15 * | 16 * |
16 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT | 17 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT |
17 * on each column. Direct algorithms are also available, but they are | 18 * on each column. Direct algorithms are also available, but they are |
18 * much more complex and seem not to be any faster when reduced to code. | 19 * much more complex and seem not to be any faster when reduced to code. |
19 * | 20 * |
20 * This implementation is based on Arai, Agui, and Nakajima's algorithm for | 21 * This implementation is based on Arai, Agui, and Nakajima's algorithm for |
21 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in | 22 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in |
22 * Japanese, but the algorithm is described in the Pennebaker & Mitchell | 23 * Japanese, but the algorithm is described in the Pennebaker & Mitchell |
23 * JPEG textbook (see REFERENCES section in file README). The following code | 24 * JPEG textbook (see REFERENCES section in file README.ijg). The following |
24 * is based directly on figure 4-8 in P&M. | 25 * code is based directly on figure 4-8 in P&M. |
25 * While an 8-point DCT cannot be done in less than 11 multiplies, it is | 26 * While an 8-point DCT cannot be done in less than 11 multiplies, it is |
26 * possible to arrange the computation so that many of the multiplies are | 27 * possible to arrange the computation so that many of the multiplies are |
27 * simple scalings of the final outputs. These multiplies can then be | 28 * simple scalings of the final outputs. These multiplies can then be |
28 * folded into the multiplications or divisions by the JPEG quantization | 29 * folded into the multiplications or divisions by the JPEG quantization |
29 * table entries. The AA&N method leaves only 5 multiplies and 29 adds | 30 * table entries. The AA&N method leaves only 5 multiplies and 29 adds |
30 * to be done in the DCT itself. | 31 * to be done in the DCT itself. |
31 * The primary disadvantage of this method is that with a fixed-point | 32 * The primary disadvantage of this method is that with a fixed-point |
32 * implementation, accuracy is lost due to imprecise representation of the | 33 * implementation, accuracy is lost due to imprecise representation of the |
33 * scaled quantization values. However, that problem does not arise if | 34 * scaled quantization values. However, that problem does not arise if |
34 * we use floating point arithmetic. | 35 * we use floating point arithmetic. |
35 */ | 36 */ |
36 | 37 |
37 #define JPEG_INTERNALS | 38 #define JPEG_INTERNALS |
38 #include "jinclude.h" | 39 #include "jinclude.h" |
39 #include "jpeglib.h" | 40 #include "jpeglib.h" |
40 #include "jdct.h"» » /* Private declarations for DCT subsystem */ | 41 #include "jdct.h" /* Private declarations for DCT subsystem */ |
41 | 42 |
42 #ifdef DCT_FLOAT_SUPPORTED | 43 #ifdef DCT_FLOAT_SUPPORTED |
43 | 44 |
44 | 45 |
45 /* | 46 /* |
46 * This module is specialized to the case DCTSIZE = 8. | 47 * This module is specialized to the case DCTSIZE = 8. |
47 */ | 48 */ |
48 | 49 |
49 #if DCTSIZE != 8 | 50 #if DCTSIZE != 8 |
50 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ | 51 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ |
51 #endif | 52 #endif |
52 | 53 |
53 | 54 |
54 /* | 55 /* |
55 * Perform the forward DCT on one block of samples. | 56 * Perform the forward DCT on one block of samples. |
56 */ | 57 */ |
57 | 58 |
58 GLOBAL(void) | 59 GLOBAL(void) |
59 jpeg_fdct_float (FAST_FLOAT * data) | 60 jpeg_fdct_float (FAST_FLOAT *data) |
60 { | 61 { |
61 FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; | 62 FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; |
62 FAST_FLOAT tmp10, tmp11, tmp12, tmp13; | 63 FAST_FLOAT tmp10, tmp11, tmp12, tmp13; |
63 FAST_FLOAT z1, z2, z3, z4, z5, z11, z13; | 64 FAST_FLOAT z1, z2, z3, z4, z5, z11, z13; |
64 FAST_FLOAT *dataptr; | 65 FAST_FLOAT *dataptr; |
65 int ctr; | 66 int ctr; |
66 | 67 |
67 /* Pass 1: process rows. */ | 68 /* Pass 1: process rows. */ |
68 | 69 |
69 dataptr = data; | 70 dataptr = data; |
70 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | 71 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { |
71 tmp0 = dataptr[0] + dataptr[7]; | 72 tmp0 = dataptr[0] + dataptr[7]; |
72 tmp7 = dataptr[0] - dataptr[7]; | 73 tmp7 = dataptr[0] - dataptr[7]; |
73 tmp1 = dataptr[1] + dataptr[6]; | 74 tmp1 = dataptr[1] + dataptr[6]; |
74 tmp6 = dataptr[1] - dataptr[6]; | 75 tmp6 = dataptr[1] - dataptr[6]; |
75 tmp2 = dataptr[2] + dataptr[5]; | 76 tmp2 = dataptr[2] + dataptr[5]; |
76 tmp5 = dataptr[2] - dataptr[5]; | 77 tmp5 = dataptr[2] - dataptr[5]; |
77 tmp3 = dataptr[3] + dataptr[4]; | 78 tmp3 = dataptr[3] + dataptr[4]; |
78 tmp4 = dataptr[3] - dataptr[4]; | 79 tmp4 = dataptr[3] - dataptr[4]; |
79 | 80 |
80 /* Even part */ | 81 /* Even part */ |
81 | 82 |
82 tmp10 = tmp0 + tmp3;» /* phase 2 */ | 83 tmp10 = tmp0 + tmp3; /* phase 2 */ |
83 tmp13 = tmp0 - tmp3; | 84 tmp13 = tmp0 - tmp3; |
84 tmp11 = tmp1 + tmp2; | 85 tmp11 = tmp1 + tmp2; |
85 tmp12 = tmp1 - tmp2; | 86 tmp12 = tmp1 - tmp2; |
86 | 87 |
87 dataptr[0] = tmp10 + tmp11; /* phase 3 */ | 88 dataptr[0] = tmp10 + tmp11; /* phase 3 */ |
88 dataptr[4] = tmp10 - tmp11; | 89 dataptr[4] = tmp10 - tmp11; |
89 | 90 |
90 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ | 91 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ |
91 dataptr[2] = tmp13 + z1;» /* phase 5 */ | 92 dataptr[2] = tmp13 + z1; /* phase 5 */ |
92 dataptr[6] = tmp13 - z1; | 93 dataptr[6] = tmp13 - z1; |
93 | 94 |
94 /* Odd part */ | 95 /* Odd part */ |
95 | 96 |
96 tmp10 = tmp4 + tmp5;» /* phase 2 */ | 97 tmp10 = tmp4 + tmp5; /* phase 2 */ |
97 tmp11 = tmp5 + tmp6; | 98 tmp11 = tmp5 + tmp6; |
98 tmp12 = tmp6 + tmp7; | 99 tmp12 = tmp6 + tmp7; |
99 | 100 |
100 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | 101 /* The rotator is modified from fig 4-8 to avoid extra negations. */ |
101 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ | 102 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ |
102 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ | 103 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ |
103 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ | 104 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ |
104 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ | 105 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ |
105 | 106 |
106 z11 = tmp7 + z3;» » /* phase 5 */ | 107 z11 = tmp7 + z3; /* phase 5 */ |
107 z13 = tmp7 - z3; | 108 z13 = tmp7 - z3; |
108 | 109 |
109 dataptr[5] = z13 + z2;» /* phase 6 */ | 110 dataptr[5] = z13 + z2; /* phase 6 */ |
110 dataptr[3] = z13 - z2; | 111 dataptr[3] = z13 - z2; |
111 dataptr[1] = z11 + z4; | 112 dataptr[1] = z11 + z4; |
112 dataptr[7] = z11 - z4; | 113 dataptr[7] = z11 - z4; |
113 | 114 |
114 dataptr += DCTSIZE;»» /* advance pointer to next row */ | 115 dataptr += DCTSIZE; /* advance pointer to next row */ |
115 } | 116 } |
116 | 117 |
117 /* Pass 2: process columns. */ | 118 /* Pass 2: process columns. */ |
118 | 119 |
119 dataptr = data; | 120 dataptr = data; |
120 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { | 121 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { |
121 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; | 122 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; |
122 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; | 123 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; |
123 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; | 124 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; |
124 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; | 125 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; |
125 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; | 126 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; |
126 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; | 127 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; |
127 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; | 128 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; |
128 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; | 129 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; |
129 | 130 |
130 /* Even part */ | 131 /* Even part */ |
131 | 132 |
132 tmp10 = tmp0 + tmp3;» /* phase 2 */ | 133 tmp10 = tmp0 + tmp3; /* phase 2 */ |
133 tmp13 = tmp0 - tmp3; | 134 tmp13 = tmp0 - tmp3; |
134 tmp11 = tmp1 + tmp2; | 135 tmp11 = tmp1 + tmp2; |
135 tmp12 = tmp1 - tmp2; | 136 tmp12 = tmp1 - tmp2; |
136 | 137 |
137 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ | 138 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ |
138 dataptr[DCTSIZE*4] = tmp10 - tmp11; | 139 dataptr[DCTSIZE*4] = tmp10 - tmp11; |
139 | 140 |
140 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ | 141 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ |
141 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ | 142 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ |
142 dataptr[DCTSIZE*6] = tmp13 - z1; | 143 dataptr[DCTSIZE*6] = tmp13 - z1; |
143 | 144 |
144 /* Odd part */ | 145 /* Odd part */ |
145 | 146 |
146 tmp10 = tmp4 + tmp5;» /* phase 2 */ | 147 tmp10 = tmp4 + tmp5; /* phase 2 */ |
147 tmp11 = tmp5 + tmp6; | 148 tmp11 = tmp5 + tmp6; |
148 tmp12 = tmp6 + tmp7; | 149 tmp12 = tmp6 + tmp7; |
149 | 150 |
150 /* The rotator is modified from fig 4-8 to avoid extra negations. */ | 151 /* The rotator is modified from fig 4-8 to avoid extra negations. */ |
151 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ | 152 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ |
152 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ | 153 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ |
153 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ | 154 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ |
154 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ | 155 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ |
155 | 156 |
156 z11 = tmp7 + z3;» » /* phase 5 */ | 157 z11 = tmp7 + z3; /* phase 5 */ |
157 z13 = tmp7 - z3; | 158 z13 = tmp7 - z3; |
158 | 159 |
159 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ | 160 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ |
160 dataptr[DCTSIZE*3] = z13 - z2; | 161 dataptr[DCTSIZE*3] = z13 - z2; |
161 dataptr[DCTSIZE*1] = z11 + z4; | 162 dataptr[DCTSIZE*1] = z11 + z4; |
162 dataptr[DCTSIZE*7] = z11 - z4; | 163 dataptr[DCTSIZE*7] = z11 - z4; |
163 | 164 |
164 dataptr++;» » » /* advance pointer to next column */ | 165 dataptr++; /* advance pointer to next column */ |
165 } | 166 } |
166 } | 167 } |
167 | 168 |
168 #endif /* DCT_FLOAT_SUPPORTED */ | 169 #endif /* DCT_FLOAT_SUPPORTED */ |
OLD | NEW |