← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/faac/oneiric

« back to all changes in this revision

Viewing changes to libfaac/fft.c

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2008-01-06 22:47:35 UTC
  • mfrom: (0.1.3 hoary) (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080106224735-jhb3ptzjfm2j7n89
Tags: 1.26-0.1ubuntu1
* Sync from debian-multimedia
* Ubuntu Changes:
 - Maintainer Spec
 - Versioned mp4v2 dep

Show diffs side-by-side

added added

removed removed

Lines of Context:
libfaac/fft.c
1
1
/*
2
2
 * FAAC - Freeware Advanced Audio Coder
3
 
 * $Id: fft.c,v 1.11 2004/04/02 14:56:17 danchr Exp $
 
3
 * $Id: fft.c,v 1.12 2005/02/02 07:49:55 sur Exp $
4
4
 * Copyright (C) 2002 Krzysztof Nikiel
5
5
 *
6
6
 * This library is free software; you can redistribute it and/or
29
29
#define MAXLOGM 9
30
30
#define MAXLOGR 8
31
31
 
 
32
#if defined DRM && !defined DRM_1024
 
33
 
 
34
#include "kiss_fft/kiss_fft.h"
 
35
#include "kiss_fft/kiss_fftr.h"
 
36
 
 
37
static const int logm_to_nfft[] = 
 
38
{
 
39
/*  0       1       2       3       */
 
40
    0,      0,      0,      0,
 
41
/*  4       5       6       7       */
 
42
    0,      0,      60,     0,
 
43
/*  8       9                       */
 
44
    240,    480
 
45
};
 
46
 
 
47
void fft_initialize( FFT_Tables *fft_tables )
 
48
{
 
49
    memset( fft_tables->cfg, 0, sizeof( fft_tables->cfg ) );
 
50
}
 
51
void fft_terminate( FFT_Tables *fft_tables )
 
52
{
 
53
    unsigned int i;
 
54
    for ( i = 0; i < sizeof( fft_tables->cfg ) / sizeof( fft_tables->cfg[0] ); i++ )
 
55
    {
 
56
        if ( fft_tables->cfg[i][0] )
 
57
        {
 
58
            free( fft_tables->cfg[i][0] );
 
59
            fft_tables->cfg[i][0] = NULL;
 
60
        }
 
61
        if ( fft_tables->cfg[i][1] )
 
62
        {
 
63
            free( fft_tables->cfg[i][1] );
 
64
            fft_tables->cfg[i][1] = NULL;
 
65
        }
 
66
    }
 
67
}
 
68
 
 
69
void rfft( FFT_Tables *fft_tables, double *x, int logm )
 
70
{
 
71
#if 0
 
72
/* sur: do not use real-only optimized FFT */
 
73
    double xi[1 << MAXLOGR];
 
74
 
 
75
    int nfft;
 
76
 
 
77
    if ( logm > MAXLOGR )
 
78
        {
 
79
                fprintf(stderr, "rfft size too big\n");
 
80
                exit(1);
 
81
        }
 
82
 
 
83
    nfft = logm_to_nfft[logm];
 
84
 
 
85
    if ( nfft )
 
86
    {
 
87
        //unsigned int i;
 
88
        //for ( i = 0; i < nfft; i++ )
 
89
        //{
 
90
        //    xi[i] = 0.0;
 
91
        //}
 
92
            memset( xi, 0, nfft * sizeof( xi[0] ) );
 
93
 
 
94
            fft( fft_tables, x, xi, logm );
 
95
 
 
96
            memcpy( x + nfft / 2, xi, ( nfft / 2 ) * sizeof(x[0]) );
 
97
    }
 
98
    else
 
99
    {
 
100
        fprintf( stderr, "bad config for logm = %d\n", logm);
 
101
        exit( 1 );
 
102
    }
 
103
 
 
104
#else
 
105
/* sur: use real-only optimized FFT */
 
106
 
 
107
    int nfft = 0;
 
108
 
 
109
    kiss_fft_scalar fin[1 << MAXLOGR];
 
110
    kiss_fft_cpx    fout[1 << MAXLOGR];
 
111
 
 
112
    if ( logm > MAXLOGR )
 
113
        {
 
114
                fprintf(stderr, "fft size too big\n");
 
115
                exit(1);
 
116
        }
 
117
 
 
118
    nfft = logm_to_nfft[logm];
 
119
 
 
120
    if ( fft_tables->cfg[logm][0] == NULL )
 
121
    {
 
122
        if ( nfft )
 
123
        {
 
124
            fft_tables->cfg[logm][0] = kiss_fftr_alloc( nfft, 0, NULL, NULL );
 
125
        }
 
126
        else
 
127
        {
 
128
                fprintf(stderr, "bad logm = %d\n", logm);
 
129
            exit( 1 );
 
130
        }
 
131
    }
 
132
 
 
133
    if ( fft_tables->cfg[logm][0] )
 
134
    {
 
135
        unsigned int i;
 
136
        
 
137
        for ( i = 0; i < nfft; i++ )
 
138
        {
 
139
            fin[i] = x[i];    
 
140
        }
 
141
        
 
142
        kiss_fftr( (kiss_fftr_cfg)fft_tables->cfg[logm][0], fin, fout );
 
143
 
 
144
        for ( i = 0; i < nfft / 2; i++ )
 
145
        {
 
146
            x[i]            = fout[i].r;
 
147
            x[i + nfft / 2] = fout[i].i;
 
148
        }
 
149
    }
 
150
    else
 
151
    {
 
152
        fprintf( stderr, "bad config for logm = %d\n", logm);
 
153
        exit( 1 );
 
154
    }
 
155
#endif
 
156
}
 
157
 
 
158
void fft( FFT_Tables *fft_tables, double *xr, double *xi, int logm )
 
159
{
 
160
    int nfft = 0;
 
161
 
 
162
    kiss_fft_cpx    fin[1 << MAXLOGM];
 
163
    kiss_fft_cpx    fout[1 << MAXLOGM];
 
164
 
 
165
    if ( logm > MAXLOGM )
 
166
        {
 
167
                fprintf(stderr, "fft size too big\n");
 
168
                exit(1);
 
169
        }
 
170
 
 
171
    nfft = logm_to_nfft[logm];
 
172
 
 
173
    if ( fft_tables->cfg[logm][0] == NULL )
 
174
    {
 
175
        if ( nfft )
 
176
        {
 
177
            fft_tables->cfg[logm][0] = kiss_fft_alloc( nfft, 0, NULL, NULL );
 
178
        }
 
179
        else
 
180
        {
 
181
                fprintf(stderr, "bad logm = %d\n", logm);
 
182
            exit( 1 );
 
183
        }
 
184
    }
 
185
 
 
186
    if ( fft_tables->cfg[logm][0] )
 
187
    {
 
188
        unsigned int i;
 
189
        
 
190
        for ( i = 0; i < nfft; i++ )
 
191
        {
 
192
            fin[i].r = xr[i];    
 
193
            fin[i].i = xi[i];
 
194
        }
 
195
        
 
196
        kiss_fft( (kiss_fft_cfg)fft_tables->cfg[logm][0], fin, fout );
 
197
 
 
198
        for ( i = 0; i < nfft; i++ )
 
199
        {
 
200
            xr[i]   = fout[i].r;
 
201
            xi[i]   = fout[i].i;
 
202
        }
 
203
    }
 
204
    else
 
205
    {
 
206
        fprintf( stderr, "bad config for logm = %d\n", logm);
 
207
        exit( 1 );
 
208
    }
 
209
}
 
210
 
 
211
void ffti( FFT_Tables *fft_tables, double *xr, double *xi, int logm )
 
212
{
 
213
    int nfft = 0;
 
214
 
 
215
    kiss_fft_cpx    fin[1 << MAXLOGM];
 
216
    kiss_fft_cpx    fout[1 << MAXLOGM];
 
217
 
 
218
    if ( logm > MAXLOGM )
 
219
        {
 
220
                fprintf(stderr, "fft size too big\n");
 
221
                exit(1);
 
222
        }
 
223
 
 
224
    nfft = logm_to_nfft[logm];
 
225
 
 
226
    if ( fft_tables->cfg[logm][1] == NULL )
 
227
    {
 
228
        if ( nfft )
 
229
        {
 
230
            fft_tables->cfg[logm][1] = kiss_fft_alloc( nfft, 1, NULL, NULL );
 
231
        }
 
232
        else
 
233
        {
 
234
                fprintf(stderr, "bad logm = %d\n", logm);
 
235
            exit( 1 );
 
236
        }
 
237
    }
 
238
    
 
239
    if ( fft_tables->cfg[logm][1] )
 
240
    {
 
241
        unsigned int i;
 
242
        double fac = 1.0 / (double)nfft;
 
243
        
 
244
        for ( i = 0; i < nfft; i++ )
 
245
        {
 
246
            fin[i].r = xr[i];    
 
247
            fin[i].i = xi[i];
 
248
        }
 
249
        
 
250
        kiss_fft( (kiss_fft_cfg)fft_tables->cfg[logm][1], fin, fout );
 
251
 
 
252
        for ( i = 0; i < nfft; i++ )
 
253
        {
 
254
            xr[i]   = fout[i].r * fac;
 
255
            xi[i]   = fout[i].i * fac;
 
256
        }
 
257
    }
 
258
    else
 
259
    {
 
260
        fprintf( stderr, "bad config for logm = %d\n", logm);
 
261
        exit( 1 );
 
262
    }
 
263
}
 
264
 
 
265
/* sur: Trying to use cfft from libfaad2 -- it does not work 'from scratch' */
 
266
//
 
267
//#include "cfft/common.h"
 
268
//
 
269
//void fft_initialize( FFT_Tables *fft_tables )
 
270
//{
 
271
//    memset( fft_tables->cfft, 0, sizeof( fft_tables->cfft ) );
 
272
//}
 
273
//void fft_terminate( FFT_Tables *fft_tables )
 
274
//{
 
275
//    unsigned int i;
 
276
//    for ( i = 0; i < sizeof( fft_tables->cfft ) / sizeof( fft_tables->cfft[0] ); i++ )
 
277
//    {
 
278
//        if ( fft_tables->cfft[i] )
 
279
//        {
 
280
//            cfftu( fft_tables->cfft[i] );
 
281
//            fft_tables->cfft[i] = NULL;
 
282
//        }
 
283
//    }
 
284
//}
 
285
//
 
286
//void rfft( FFT_Tables *fft_tables, double *x, int logm )
 
287
//{
 
288
//      double xi[1 << MAXLOGR];
 
289
//
 
290
//    int nfft;
 
291
//
 
292
//    if ( logm > MAXLOGR )
 
293
//      {
 
294
//              fprintf(stderr, "rfft size too big\n");
 
295
//              exit(1);
 
296
//      }
 
297
//
 
298
//    nfft = logm_to_nfft[logm];
 
299
//
 
300
//    if ( nfft )
 
301
//    {
 
302
//        unsigned int i;
 
303
//
 
304
//        for ( i = 0; i < nfft; i++ )
 
305
//        {
 
306
//            xi[i] = 0.0;
 
307
//        }
 
308
//          //memset( xi, 0, nfft * sizeof( xi[0] ) );
 
309
//
 
310
//          fft( fft_tables, x, xi, logm );
 
311
//
 
312
//          memcpy( x + nfft / 2, xi, ( nfft / 2 ) * sizeof(x[0]) );
 
313
//
 
314
//#ifdef SUR_DEBUG_FFT
 
315
//        {
 
316
//            FILE* f = fopen( "fft.log", "at" );
 
317
//            
 
318
//            fprintf( f, "RFFT(%d)\n", nfft );
 
319
//            
 
320
//            for ( i = 0; i < nfft; i++ )
 
321
//            {
 
322
//                fprintf( f, ";%d;%g;%g\n", i, x[i], xi[i] );
 
323
//            }
 
324
//
 
325
//            fclose( f );
 
326
//        }
 
327
//#endif
 
328
//    }
 
329
//    else
 
330
//    {
 
331
//        fprintf( stderr, "bad config for logm = %d\n", logm);
 
332
//        exit( 1 );
 
333
//    }
 
334
//}
 
335
//
 
336
//void fft( FFT_Tables *fft_tables, double *xr, double *xi, int logm )
 
337
//{
 
338
//    int nfft;
 
339
//
 
340
//    complex_t c[1 << MAXLOGM];
 
341
//
 
342
//    if ( logm > MAXLOGM )
 
343
//      {
 
344
//              fprintf(stderr, "fft size too big\n");
 
345
//              exit(1);
 
346
//      }
 
347
//
 
348
//    nfft = logm_to_nfft[logm];
 
349
//
 
350
//    if ( fft_tables->cfft[logm] == NULL )
 
351
//    {
 
352
//        if ( nfft )
 
353
//        {
 
354
//            fft_tables->cfft[logm] = cffti( nfft );
 
355
//        }
 
356
//        else
 
357
//        {
 
358
//              fprintf(stderr, "bad logm = %d\n", logm);
 
359
//            exit( 1 );
 
360
//        }
 
361
//    }
 
362
//
 
363
//    if ( fft_tables->cfft[logm] )
 
364
//    {
 
365
//        unsigned int i;
 
366
//        
 
367
//        for ( i = 0; i < nfft; i++ )
 
368
//        {
 
369
//            RE( c[i] ) = xr[i];    
 
370
//            IM( c[i] ) = xi[i];
 
371
//        }
 
372
//        
 
373
//        cfftf( fft_tables->cfft[logm], c );
 
374
//
 
375
//        for ( i = 0; i < nfft; i++ )
 
376
//        {
 
377
//            xr[i]   = RE( c[i] );
 
378
//            xi[i]   = IM( c[i] );
 
379
//        }
 
380
//
 
381
//#ifdef SUR_DEBUG_FFT
 
382
//        {
 
383
//            FILE* f = fopen( "fft.log", "at" );
 
384
//            
 
385
//            fprintf( f, "FFT(%d)\n", nfft );
 
386
//            
 
387
//            for ( i = 0; i < nfft; i++ )
 
388
//            {
 
389
//                fprintf( f, ";%d;%g;%g\n", i, xr[i], xi[i] );
 
390
//            }
 
391
//
 
392
//            fclose( f );
 
393
//        }
 
394
//#endif
 
395
//    }
 
396
//    else
 
397
//    {
 
398
//        fprintf( stderr, "bad config for logm = %d\n", logm);
 
399
//        exit( 1 );
 
400
//    }
 
401
//}
 
402
//
 
403
//void ffti( FFT_Tables *fft_tables, double *xr, double *xi, int logm )
 
404
//{
 
405
//    int nfft;
 
406
//
 
407
//    complex_t c[1 << MAXLOGM];
 
408
//
 
409
//    if ( logm > MAXLOGM )
 
410
//      {
 
411
//              fprintf(stderr, "fft size too big\n");
 
412
//              exit(1);
 
413
//      }
 
414
//
 
415
//    nfft = logm_to_nfft[logm];
 
416
//
 
417
//    if ( fft_tables->cfft[logm] == NULL )
 
418
//    {
 
419
//        if ( nfft )
 
420
//        {
 
421
//            fft_tables->cfft[logm] = cffti( nfft );
 
422
//        }
 
423
//        else
 
424
//        {
 
425
//              fprintf(stderr, "bad logm = %d\n", logm);
 
426
//            exit( 1 );
 
427
//        }
 
428
//    }
 
429
//    
 
430
//    if ( fft_tables->cfft[logm] )
 
431
//    {
 
432
//        unsigned int i;
 
433
//        
 
434
//        for ( i = 0; i < nfft; i++ )
 
435
//        {
 
436
//            RE( c[i] )  = xr[i];    
 
437
//            IM( c[i] )  = xi[i];
 
438
//        }
 
439
//        
 
440
//        cfftb( fft_tables->cfft[logm], c );
 
441
//
 
442
//        for ( i = 0; i < nfft; i++ )
 
443
//        {
 
444
//            xr[i]   = RE( c[i] );
 
445
//            xi[i]   = IM( c[i] );
 
446
//        }
 
447
//
 
448
//#ifdef SUR_DEBUG_FFT
 
449
//        {
 
450
//            FILE* f = fopen( "fft.log", "at" );
 
451
//            
 
452
//            fprintf( f, "FFTI(%d)\n", nfft );
 
453
//            
 
454
//            for ( i = 0; i < nfft; i++ )
 
455
//            {
 
456
//                fprintf( f, ";%d;%g;%g\n", i, xr[i], xi[i] );
 
457
//            }
 
458
//
 
459
//            fclose( f );
 
460
//        }
 
461
//#endif
 
462
//    }
 
463
//    else
 
464
//    {
 
465
//        fprintf( stderr, "bad config for logm = %d\n", logm);
 
466
//        exit( 1 );
 
467
//    }
 
468
//}
 
469
 
 
470
#else /* !defined DRM || defined DRM_1024 */
 
471
 
32
472
void fft_initialize( FFT_Tables *fft_tables )
33
473
{
34
474
        int i;
236
676
        }
237
677
}
238
678
 
 
679
#endif /* defined DRM && !defined DRM_1024 */
 
680
 
239
681
/*
240
682
$Log: fft.c,v $
 
683
Revision 1.12  2005/02/02 07:49:55  sur
 
684
Added interface to kiss_fft library to implement FFT for 960 transform length.
 
685
 
241
686
Revision 1.11  2004/04/02 14:56:17  danchr
242
687
fix name clash w/ libavcodec: fft_init -> fft_initialize
243
688
bump version number to 1.24 beta