comparison src/vector.c @ 56:450712b21565

Added namespacing to enumerations and defines. Made most macros private.

 
 
 /* xtract_vector.c: defines functions that extract a feature as a single value from an input vector */
 
 #include "xtract/libxtract.h"
+#include "xtract_macros_private.h"
 #include <math.h>
 #include <string.h>
 #include <stdlib.h>
 
 #ifdef XTRACT_FFT
 
 #include <fftw3.h>
 
 int xtract_spectrum(const float *data, const int N, const void *argv, float *result){
 
-    float *input, *rfft, nyquist, temp;
+    float *input, *rfft, q, temp;
     size_t bytes;
     int n , NxN, M, vector;
     fftwf_plan plan;
 
     M = N >> 1;
-    NxN = SQ(N);
+    NxN = XTRACT_SQ(N);
 
     rfft = (float *)fftwf_malloc(N * sizeof(float));
     input = (float *)malloc(bytes = N * sizeof(float));
     input = memcpy(input, data, bytes);
 
-    nyquist = *(float *)argv;
+    q = *(float *)argv;
     vector = (int)*((float *)argv+1);
 
-    CHECK_nyquist;
+    XTRACT_CHECK_q;
 
     plan = fftwf_plan_r2r_1d(N, input, rfft, FFTW_R2HC, FFTW_ESTIMATE);
     
     fftwf_execute(plan);
 
     switch(vector){
-	case MAGNITUDE_SPECTRUM:
-	    for(n = 0; n < M; n++){
-		result[n] = sqrt(SQ(rfft[n]) + SQ(rfft[N - n])) / N; 
-		result[M + n] = n * nyquist;
-	    }
-	    break;
-	case LOG_MAGNITUDE_SPECTRUM:
-	    for(n = 0; n < M; n++){
-		if ((temp = SQ(rfft[n]) + SQ(rfft[N - n])) > LOG_LIMIT)
+	case XTRACT_MAGNITUDE_SPECTRUM:
+	    for(n = 0; n < M; n++){
+		result[n] = sqrt(XTRACT_SQ(rfft[n]) + XTRACT_SQ(rfft[N - n])) / N; 
+		result[M + n] = n * q;
+	    }
+	    break;
+	case XTRACT_LOG_MAGNITUDE_SPECTRUM:
+	    for(n = 0; n < M; n++){
+		if ((temp = XTRACT_SQ(rfft[n]) + XTRACT_SQ(rfft[N - n])) > XTRACT_LOG_LIMIT)
 		    temp = log(sqrt(temp) / N);
 		else
-		    temp = LOG_LIMIT_DB;
+		    temp = XTRACT_LOG_LIMIT_DB;
 		/*Normalise*/
-		result[n] = (temp + DB_SCALE_OFFSET) / DB_SCALE_OFFSET; 
-		result[M + n] = n * nyquist;
-	    }
-	    break;
-	case POWER_SPECTRUM:
-	    for(n = 0; n < M; n++){
-		result[n] = (SQ(rfft[n]) + SQ(rfft[N - n])) / NxN;
-		result[M + n] = n * nyquist;
-	    }
-	    break;
-	case LOG_POWER_SPECTRUM:
-	    for(n = 0; n < M; n++){
-		if ((temp = SQ(rfft[n]) + SQ(rfft[N - n])) > LOG_LIMIT)
+		result[n] = (temp + XTRACT_DB_SCALE_OFFSET) / XTRACT_DB_SCALE_OFFSET; 
+		result[M + n] = n * q;
+	    }
+	    break;
+	case XTRACT_POWER_SPECTRUM:
+	    for(n = 0; n < M; n++){
+		result[n] = (XTRACT_SQ(rfft[n]) + XTRACT_SQ(rfft[N - n])) / NxN;
+		result[M + n] = n * q;
+	    }
+	    break;
+	case XTRACT_LOG_POWER_SPECTRUM:
+	    for(n = 0; n < M; n++){
+		if ((temp = XTRACT_SQ(rfft[n]) + XTRACT_SQ(rfft[N - n])) > XTRACT_LOG_LIMIT)
 		    temp = log(temp / NxN);
 		else
-		    temp = LOG_LIMIT_DB; 		
-		result[n] = (temp + DB_SCALE_OFFSET) / DB_SCALE_OFFSET; 
-		result[M + n] = n * nyquist;
+		    temp = XTRACT_LOG_LIMIT_DB; 		
+		result[n] = (temp + XTRACT_DB_SCALE_OFFSET) / XTRACT_DB_SCALE_OFFSET; 
+		result[M + n] = n * q;
 	    }
 	    break;
 	default:
 	    /* MAGNITUDE_SPECTRUM */
 	    for(n = 0; n < M; n++){
-		result[n] = sqrt(SQ(rfft[n]) + SQ(rfft[N - n])) / N; 
-		result[M + n] = n * nyquist;
+		result[n] = sqrt(XTRACT_SQ(rfft[n]) + XTRACT_SQ(rfft[N - n])) / N; 
+		result[M + n] = n * q;
 	    }
 	    break;
     }
     
     /* result[0] = fabs(temp[0]) / N  */
-    result[M] = nyquist * .5;
+    result[N] = q * M;
     
     fftwf_destroy_plan(plan);
     fftwf_free(rfft);
     free(input);
     
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 int xtract_autocorrelation_fft(const float *data, const int N, const void *argv, float *result){
     
     float *temp, *input;

     
     fftwf_destroy_plan(plan);
     fftwf_free(temp);
     free(input);
 
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 int xtract_mfcc(const float *data, const int N, const void *argv, float *result){
 
     xtract_mel_filter *f;

     
     for(filter = 0; filter < f->n_filters; filter++){
         for(n = 0; n < N; n++){
             result[filter] += input[n] * f->filters[filter][n];
         }
-        if(result[filter] < LOG_LIMIT) result[filter] = LOG_LIMIT;
+        if(result[filter] < XTRACT_LOG_LIMIT) result[filter] = XTRACT_LOG_LIMIT;
         result[filter] = log(result[filter]);
     }
 
     for(n = filter + 1; n < N; n++) result[n] = 0; 
     
     xtract_dct(result, f->n_filters, NULL, result);
 
     free(input);
     
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 int xtract_dct(const float *data, const int N, const void *argv, float *result){
     
     fftwf_plan plan;

     
     fftwf_execute(plan);
     fftwf_destroy_plan(plan);
     free(input);
 
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 #else
 
 int xtract_magnitude_spectrum(const float *data, const int N, const void *argv, float *result){

             corr += data[i] * data[i + n];
         }
         result[n] = corr / N;
     }
 
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 int xtract_amdf(const float *data, const int N, const void *argv, float *result){
 
     int n = N, i;

 			md += temp;
         }
         result[n] = md / N;
     }
 
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 int xtract_asdf(const float *data, const int N, const void *argv, float *result){
     
     int n = N, i;

 
     while(n--){
        sd = 0;
         for(i = 0; i < N - n; i++){
             /*sd = 1;*/
-            sd += SQ(data[i] - data[i + n]);
+            sd += XTRACT_SQ(data[i] - data[i + n]);
         }
         result[n] = sd / N;
     }
 
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 int xtract_bark_coefficients(const float *data, const int N, const void *argv, float *result){
 
     int *limits, band, n;
 
     limits = (int *)argv;
     
-    for(band = 0; band < BARK_BANDS; band++){
+    for(band = 0; band < XTRACT_BARK_BANDS; band++){
         for(n = limits[band]; n < limits[band + 1]; n++)
             result[band] += data[n];
     }
 
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }
 
 int xtract_peak_spectrum(const float *data, const int N, const void *argv, float *result){
 
-    float threshold, max, y, y2, y3, p, nyquist, *input = NULL;
-    size_t bytes;
-    int n = N, M, rv = SUCCESS;
-
-    threshold = max = y = y2 = y3 = p = nyquist = 0.f;
+    float threshold, max, y, y2, y3, p, q, *input = NULL;
+    size_t bytes;
+    int n = N, M, rv = XTRACT_SUCCESS;
+
+    threshold = max = y = y2 = y3 = p = q = 0.f;
     
     if(argv != NULL){
-        nyquist = ((float *)argv)[0];
+        q = ((float *)argv)[0];
         threshold = ((float *)argv)[1];
     }
     else
-        rv = BAD_ARGV;
+        rv = XTRACT_BAD_ARGV;
 
     if(threshold < 0 || threshold > 100){
         threshold = 0;
-        rv = BAD_ARGV;
-    }
-
-    CHECK_nyquist;
+        rv = XTRACT_BAD_ARGV;
+    }
+
+    XTRACT_CHECK_q;
 
     input = (float *)malloc(bytes = N * sizeof(float));
 
     if(input != NULL)
 	input = memcpy(input, data, bytes);
     else
-	return MALLOC_FAILED;
+	return XTRACT_MALLOC_FAILED;
 
     M = N >> 1;
 
     while(n--)
-        max = MAX(max, input[n]);
+        max = XTRACT_MAX(max, input[n]);
     
     threshold *= .01 * max;
 
     result[0] = 0;
     result[M] = 0;
 
     for(n = 1; n < M; n++){
         if(input[n] >= threshold){
             if(input[n] > input[n - 1] && input[n] > input[n + 1]){
-                result[M + n] = nyquist * (n + (p = .5 * (y = input[n-1] - 
+                result[M + n] = q * (n + (p = .5 * (y = input[n-1] - 
 				(y3 = input[n+1])) / (input[n - 1] - 2 * 
 				    (y2 = input[n]) + input[n + 1])));
                 result[n] = y2 - .25 * (y - y3) * p;
             }
             else{

             result[M + n] = 0;
         }
     }	  
    
     free(input);
-    return (rv ? rv : SUCCESS);
+    return (rv ? rv : XTRACT_SUCCESS);
 }
 	    
 int xtract_harmonic_spectrum(const float *data, const int N, const void *argv, float *result){
     
     int n = (N >> 1), M = n; 

 	    }
 	}
 	else
 	    result[n] = result[M + n] = 0.f;
     }
-    return SUCCESS;
+    return XTRACT_SUCCESS;
 }