Mercurial > libavcodec.hg
comparison fft.c @ 2967:ef2149182f1c libavcodec
COSMETICS: Remove all trailing whitespace.
| author | diego |
|---|---|
| date | Sat, 17 Dec 2005 18:14:38 +0000 |
| parents | dd63cb7e5080 |
| children | bfabfdf9ce55 |
comparison
equal
deleted
inserted
replaced
| 2966:564788471dd4 | 2967:ef2149182f1c |
|---|---|
| 24 | 24 |
| 25 #include "dsputil.h" | 25 #include "dsputil.h" |
| 26 | 26 |
| 27 /** | 27 /** |
| 28 * The size of the FFT is 2^nbits. If inverse is TRUE, inverse FFT is | 28 * The size of the FFT is 2^nbits. If inverse is TRUE, inverse FFT is |
| 29 * done | 29 * done |
| 30 */ | 30 */ |
| 31 int ff_fft_init(FFTContext *s, int nbits, int inverse) | 31 int ff_fft_init(FFTContext *s, int nbits, int inverse) |
| 32 { | 32 { |
| 33 int i, j, m, n; | 33 int i, j, m, n; |
| 34 float alpha, c1, s1, s2; | 34 float alpha, c1, s1, s2; |
| 35 | 35 |
| 36 s->nbits = nbits; | 36 s->nbits = nbits; |
| 37 n = 1 << nbits; | 37 n = 1 << nbits; |
| 38 | 38 |
| 39 s->exptab = av_malloc((n / 2) * sizeof(FFTComplex)); | 39 s->exptab = av_malloc((n / 2) * sizeof(FFTComplex)); |
| 40 if (!s->exptab) | 40 if (!s->exptab) |
| 43 if (!s->revtab) | 43 if (!s->revtab) |
| 44 goto fail; | 44 goto fail; |
| 45 s->inverse = inverse; | 45 s->inverse = inverse; |
| 46 | 46 |
| 47 s2 = inverse ? 1.0 : -1.0; | 47 s2 = inverse ? 1.0 : -1.0; |
| 48 | 48 |
| 49 for(i=0;i<(n/2);i++) { | 49 for(i=0;i<(n/2);i++) { |
| 50 alpha = 2 * M_PI * (float)i / (float)n; | 50 alpha = 2 * M_PI * (float)i / (float)n; |
| 51 c1 = cos(alpha); | 51 c1 = cos(alpha); |
| 52 s1 = sin(alpha) * s2; | 52 s1 = sin(alpha) * s2; |
| 53 s->exptab[i].re = c1; | 53 s->exptab[i].re = c1; |
| 68 has_vectors = mm_support() & MM_ALTIVEC; | 68 has_vectors = mm_support() & MM_ALTIVEC; |
| 69 #endif | 69 #endif |
| 70 if (has_vectors) { | 70 if (has_vectors) { |
| 71 int np, nblocks, np2, l; | 71 int np, nblocks, np2, l; |
| 72 FFTComplex *q; | 72 FFTComplex *q; |
| 73 | 73 |
| 74 np = 1 << nbits; | 74 np = 1 << nbits; |
| 75 nblocks = np >> 3; | 75 nblocks = np >> 3; |
| 76 np2 = np >> 1; | 76 np2 = np >> 1; |
| 77 s->exptab1 = av_malloc(np * 2 * sizeof(FFTComplex)); | 77 s->exptab1 = av_malloc(np * 2 * sizeof(FFTComplex)); |
| 78 if (!s->exptab1) | 78 if (!s->exptab1) |
| 142 } | 142 } |
| 143 | 143 |
| 144 /** | 144 /** |
| 145 * Do a complex FFT with the parameters defined in ff_fft_init(). The | 145 * Do a complex FFT with the parameters defined in ff_fft_init(). The |
| 146 * input data must be permuted before with s->revtab table. No | 146 * input data must be permuted before with s->revtab table. No |
| 147 * 1.0/sqrt(n) normalization is done. | 147 * 1.0/sqrt(n) normalization is done. |
| 148 */ | 148 */ |
| 149 void ff_fft_calc_c(FFTContext *s, FFTComplex *z) | 149 void ff_fft_calc_c(FFTContext *s, FFTComplex *z) |
| 150 { | 150 { |
| 151 int ln = s->nbits; | 151 int ln = s->nbits; |
| 152 int j, np, np2; | 152 int j, np, np2; |
| 161 /* pass 0 */ | 161 /* pass 0 */ |
| 162 | 162 |
| 163 p=&z[0]; | 163 p=&z[0]; |
| 164 j=(np >> 1); | 164 j=(np >> 1); |
| 165 do { | 165 do { |
| 166 BF(p[0].re, p[0].im, p[1].re, p[1].im, | 166 BF(p[0].re, p[0].im, p[1].re, p[1].im, |
| 167 p[0].re, p[0].im, p[1].re, p[1].im); | 167 p[0].re, p[0].im, p[1].re, p[1].im); |
| 168 p+=2; | 168 p+=2; |
| 169 } while (--j != 0); | 169 } while (--j != 0); |
| 170 | 170 |
| 171 /* pass 1 */ | 171 /* pass 1 */ |
| 172 | 172 |
| 173 | 173 |
| 174 p=&z[0]; | 174 p=&z[0]; |
| 175 j=np >> 2; | 175 j=np >> 2; |
| 176 if (s->inverse) { | 176 if (s->inverse) { |
| 177 do { | 177 do { |
| 178 BF(p[0].re, p[0].im, p[2].re, p[2].im, | 178 BF(p[0].re, p[0].im, p[2].re, p[2].im, |
| 179 p[0].re, p[0].im, p[2].re, p[2].im); | 179 p[0].re, p[0].im, p[2].re, p[2].im); |
| 180 BF(p[1].re, p[1].im, p[3].re, p[3].im, | 180 BF(p[1].re, p[1].im, p[3].re, p[3].im, |
| 181 p[1].re, p[1].im, -p[3].im, p[3].re); | 181 p[1].re, p[1].im, -p[3].im, p[3].re); |
| 182 p+=4; | 182 p+=4; |
| 183 } while (--j != 0); | 183 } while (--j != 0); |
| 184 } else { | 184 } else { |
| 185 do { | 185 do { |
| 186 BF(p[0].re, p[0].im, p[2].re, p[2].im, | 186 BF(p[0].re, p[0].im, p[2].re, p[2].im, |
| 187 p[0].re, p[0].im, p[2].re, p[2].im); | 187 p[0].re, p[0].im, p[2].re, p[2].im); |
| 188 BF(p[1].re, p[1].im, p[3].re, p[3].im, | 188 BF(p[1].re, p[1].im, p[3].re, p[3].im, |
| 189 p[1].re, p[1].im, p[3].im, -p[3].re); | 189 p[1].re, p[1].im, p[3].im, -p[3].re); |
| 190 p+=4; | 190 p+=4; |
| 191 } while (--j != 0); | 191 } while (--j != 0); |
| 192 } | 192 } |
| 193 /* pass 2 .. ln-1 */ | 193 /* pass 2 .. ln-1 */ |
| 199 p = z; | 199 p = z; |
| 200 q = z + nloops; | 200 q = z + nloops; |
| 201 for (j = 0; j < nblocks; ++j) { | 201 for (j = 0; j < nblocks; ++j) { |
| 202 BF(p->re, p->im, q->re, q->im, | 202 BF(p->re, p->im, q->re, q->im, |
| 203 p->re, p->im, q->re, q->im); | 203 p->re, p->im, q->re, q->im); |
| 204 | 204 |
| 205 p++; | 205 p++; |
| 206 q++; | 206 q++; |
| 207 for(l = nblocks; l < np2; l += nblocks) { | 207 for(l = nblocks; l < np2; l += nblocks) { |
| 208 CMUL(tmp_re, tmp_im, exptab[l].re, exptab[l].im, q->re, q->im); | 208 CMUL(tmp_re, tmp_im, exptab[l].re, exptab[l].im, q->re, q->im); |
| 209 BF(p->re, p->im, q->re, q->im, | 209 BF(p->re, p->im, q->re, q->im, |
| 226 void ff_fft_permute(FFTContext *s, FFTComplex *z) | 226 void ff_fft_permute(FFTContext *s, FFTComplex *z) |
| 227 { | 227 { |
| 228 int j, k, np; | 228 int j, k, np; |
| 229 FFTComplex tmp; | 229 FFTComplex tmp; |
| 230 const uint16_t *revtab = s->revtab; | 230 const uint16_t *revtab = s->revtab; |
| 231 | 231 |
| 232 /* reverse */ | 232 /* reverse */ |
| 233 np = 1 << s->nbits; | 233 np = 1 << s->nbits; |
| 234 for(j=0;j<np;j++) { | 234 for(j=0;j<np;j++) { |
| 235 k = revtab[j]; | 235 k = revtab[j]; |
| 236 if (k < j) { | 236 if (k < j) { |