Fix crashes with VBR for short duration frames and very low bitrates. This may, howev...
[opus.git] / tests / real-fft-test.c
index 952a83b..f4bb20b 100644 (file)
@@ -1,27 +1,26 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 #include "kiss_fftr.h"
 #include "_kiss_fft_guts.h"
-#include <sys/times.h>
-#include <time.h>
-#include <unistd.h>
 #include <stdio.h>
 #include <string.h>
 
-static double cputime(void)
-{
-    struct tms t;
-    times(&t);
-    return (double)(t.tms_utime + t.tms_stime)/  sysconf(_SC_CLK_TCK) ;
-}
+#define CELT_C 
+#include "../libcelt/stack_alloc.h"
+#include "../libcelt/kiss_fft.c"
+#include "../libcelt/kiss_fftr.c"
+
+#ifdef FIXED_DEBUG
+long long celt_mips=0;
+#endif
+int ret=0;
 
 static
 kiss_fft_scalar rand_scalar(void) 
 {
-#ifdef USE_SIMD
-    return _mm_set1_ps(rand()-RAND_MAX/2);
-#else
-    kiss_fft_scalar s = (kiss_fft_scalar)(rand() -RAND_MAX/2);
-    return s/2;
-#endif
+    return (rand()%32767)-16384;
 }
 
 static
@@ -30,19 +29,22 @@ double snr_compare( kiss_fft_cpx * vec1,kiss_fft_scalar * vec2, int n)
     int k;
     double sigpow=1e-10, noisepow=1e-10, err,snr;
 
-    for (k=1;k<n;++k) {
+    vec1[0].i = vec1[n].r;
+    for (k=0;k<n;++k) {
         sigpow += (double)vec1[k].r * (double)vec1[k].r + 
                   (double)vec1[k].i * (double)vec1[k].i;
         err = (double)vec1[k].r - (double)vec2[2*k];
+        /*printf ("%f %f\n", (double)vec1[k].r, (double)vec2[2*k]);*/
         noisepow += err * err;
         err = (double)vec1[k].i - (double)vec2[2*k+1];
+        /*printf ("%f %f\n", (double)vec1[k].i, (double)vec2[2*k+1]);*/
         noisepow += err * err;
 
     }
     snr = 10*log10( sigpow / noisepow );
-    if (snr<10) {
-        printf( "\npoor snr: %f\n", snr);
-        exit(1);
+    if (snr<60) {
+        printf( "** poor snr: %f **\n", snr);
+        ret = 1;
     }
     return snr;
 }
@@ -53,19 +55,23 @@ double snr_compare_scal( kiss_fft_scalar * vec1,kiss_fft_scalar * vec2, int n)
     int k;
     double sigpow=1e-10, noisepow=1e-10, err,snr;
 
-    for (k=1;k<n;++k) {
+    for (k=0;k<n;++k) {
         sigpow += (double)vec1[k] * (double)vec1[k];
         err = (double)vec1[k] - (double)vec2[k];
         noisepow += err * err;
     }
     snr = 10*log10( sigpow / noisepow );
-    if (snr<10) {
+    if (snr<60) {
         printf( "\npoor snr: %f\n", snr);
-        exit(1);
+        ret = 1;
     }
     return snr;
 }
+#ifdef RADIX_TWO_ONLY
+#define NFFT 1024
+#else
 #define NFFT 8*3*5
+#endif
 
 #ifndef NUMFFTS
 #define NUMFFTS 10000
@@ -74,7 +80,6 @@ double snr_compare_scal( kiss_fft_scalar * vec1,kiss_fft_scalar * vec2, int n)
 
 int main(void)
 {
-    double ts,tfft,trfft;
     int i;
     kiss_fft_cpx cin[NFFT];
     kiss_fft_cpx cout[NFFT];
@@ -86,46 +91,27 @@ int main(void)
     kiss_fft_scalar rin[NFFT+2];
     kiss_fft_scalar rout[NFFT+2];
     kiss_fft_scalar zero;
+    ALLOC_STACK;
     memset(&zero,0,sizeof(zero) ); // ugly way of setting short,int,float,double, or __m128 to zero
 
-    srand(time(0));
-
     for (i=0;i<NFFT;++i) {
         rin[i] = rand_scalar();
+#if defined(FIXED_POINT) && defined(DOUBLE_PRECISION)
+        rin[i] *= 32768;
+#endif
         cin[i].r = rin[i];
         cin[i].i = zero;
     }
 
-    kiss_fft_state = kiss_fft_alloc(NFFT,0,0,0);
-    kiss_fftr_state = kiss_fftr_alloc(NFFT,0,0,0);
+    kiss_fft_state = kiss_fft_alloc(NFFT,0,0);
+    kiss_fftr_state = kiss_fftr_alloc(NFFT,0,0);
     kiss_fft(kiss_fft_state,cin,cout);
     kiss_fftr(kiss_fftr_state,rin,sout);
     
     printf( "nfft=%d, inverse=%d, snr=%g\n",
             NFFT,0, snr_compare(cout,sout,(NFFT/2)) );
-    ts = cputime();
-    for (i=0;i<NUMFFTS;++i) {
-        kiss_fft(kiss_fft_state,cin,cout);
-    }
-    tfft = cputime() - ts;
-    
-    ts = cputime();
-    for (i=0;i<NUMFFTS;++i) {
-        kiss_fftr( kiss_fftr_state, rin, sout );
-        /* kiss_fftri(kiss_fftr_state,cout,rin); */
-    }
-    trfft = cputime() - ts;
-
-    printf("%d complex ffts took %gs, real took %gs\n",NUMFFTS,tfft,trfft);
-
-    free(kiss_fft_state);
-    free(kiss_fftr_state);
-
-    kiss_fft_state = kiss_fft_alloc(NFFT,1,0,0);
-    kiss_fftr_state = kiss_fftr_alloc(NFFT,1,0,0);
 
     memset(cin,0,sizeof(cin));
-#if 1
     cin[0].r = rand_scalar();
     cin[NFFT/2].r = rand_scalar();
     for (i=1;i< NFFT/2;++i) {
@@ -133,11 +119,6 @@ int main(void)
         cin[i].r = rand_scalar();
         cin[i].i = rand_scalar();
     }
-#else
-    cin[0].r = 12000;
-    cin[3].r = 12000;
-    cin[NFFT/2].r = 12000;
-#endif
 
     // conjugate symmetry of real signal 
     for (i=1;i< NFFT/2;++i) {
@@ -145,6 +126,20 @@ int main(void)
         cin[NFFT-i].i = - cin[i].i;
     }
 
+    
+#ifdef FIXED_POINT
+#ifdef DOUBLE_PRECISION
+    for (i=0;i< NFFT;++i) {
+       cin[i].r *= 32768;
+       cin[i].i *= 32768;
+    }
+#endif
+    for (i=0;i< NFFT;++i) {
+       cin[i].r /= NFFT;
+       cin[i].i /= NFFT;
+    }
+#endif
+    
     fin[0] = cin[0].r;
     fin[1] = cin[NFFT/2].r;
     for (i=1;i< NFFT/2;++i)
@@ -153,7 +148,7 @@ int main(void)
        fin[2*i+1] = cin[i].i;
     }
     
-    kiss_fft(kiss_fft_state,cin,cout);
+    kiss_ifft(kiss_fft_state,cin,cout);
     kiss_fftri(kiss_fftr_state,fin,rout);
     /*
     printf(" results from inverse kiss_fft : (%f,%f), (%f,%f), (%f,%f), (%f,%f), (%f,%f) ...\n "
@@ -172,5 +167,5 @@ int main(void)
     free(kiss_fft_state);
     free(kiss_fftr_state);
 
-    return 0;
+    return ret;
 }