//=======================================================================================
// EJECUCIÓN FILTRO FIR
//=======================================================================================
int main(int argc, char *argv[])
{
unsigned short i,j,L,LE,LE1;
for (L=1; L<=EXP; L++) // Create twiddle factor table
{
LE=1<<L;
LE1=LE>>1;
W[L-1].re = cos(pi/LE1);
W[L-1].im = -sin(pi/LE1);
}
for (j=0; j<(13*N); j++) // este for deberia ser solo hasta j<13, para lograr el efecto de 13*128=1664 (tamaño del archivo .dat)
{
for (i=0; i<N; i++);
{
X[i].re = input7_f[j++]; // input7_f[j*i]
X[i].im = 0.0;
}
// Start FFT
bit_rev(X,EXP);
fft(X,EXP,W,1);
for (i=0; i<N; i++)
{
temp.re = X[i].re*X[i].re;
temp.im = X[i].im*X[i].im;
spectrum[i] = (short)((temp.re+temp.im)*32767); // spectrum[j*i]
}
}
return (0);
}
void ifft_Npt(int *inputX, int *inputY, int *X_out, int *Y_out,int N)
{
int i,j,k;
int offset=0;
int Set_Count=1;
#ifdef DOUBLE_CALCULATIONS
double theta = convert_to_cordic_weight(2*pi/N);
double Set_theta,Butterfly_theta;
#else
int theta = convert_to_cordic_weight(2*pi/N);
int Set_theta,Butterfly_theta;
#endif
int X_in[1024],Y_in[1024];
int X_temp[3],Y_temp[3];
for(i=0;i<N;i++){
X_in[i]=inputX[i];
Y_in[i]=inputY[i];
}
Set_theta = theta;
for(i=N/2;i>=1;i=i/2){
offset = 0;
for(j=0;j<Set_Count;j++){
Butterfly_theta = 0;
for(k=0;k<i;k++){
X_temp[0] = X_in[k+offset]+X_in[k+i+offset];
Y_temp[0] = Y_in[k+offset]+Y_in[k+i+offset];
X_temp[1] = X_in[k+offset]-X_in[k+i+offset];
Y_temp[1] = Y_in[k+offset]-Y_in[k+i+offset];
//X_temp[2] = (X_temp[1]*cos(Butterfly_theta)) + (Y_temp[1]*sin(Butterfly_theta));
//Y_temp[2] = (-(X_temp[1]*sin(Butterfly_theta))) + (Y_temp[1]*cos(Butterfly_theta));
#ifdef DOUBLE_CALCULATIONS
cordic_rotate_double(&X_temp[1],&Y_temp[1],-Butterfly_theta);
#else
cordic_rotate_int(&X_temp[1],&Y_temp[1],-Butterfly_theta);
#endif
X_temp[2] = X_temp[1];
Y_temp[2] = Y_temp[1];
X_in[k+offset] = X_temp[0]>>1;
Y_in[k+offset] = Y_temp[0]>>1;
X_in[k+i+offset] = X_temp[2]>>1;
Y_in[k+i+offset] = Y_temp[2]>>1;
Butterfly_theta += Set_theta;
}
offset +=i*2;
}
Set_Count = Set_Count*2;
Set_theta = Set_theta*2;
// printf("---------\n");
}
for(i=0;i<N;i++){
j = bit_rev(i,N);
X_out[i] = X_in[j];
Y_out[i] = Y_in[j];
}
}
void FFT(float*x, float*X, unsigned short M) {
int N;
N = (int) 2*M; //Integer of merit for many functions called herein. Equal to the number of complex values that'll be in 'X' (which is twice as many as in 'x')
int a; //Counter variable, gets used in several "for" loops.
int b; /*This will be used for some of the bookkeeping in the loop immediately below */
int c; /*Similar to b, this is used for different matrix indexing.*/
for (a=0; a<M; a++) //Assign the data from x to every other slot in X, inserting zeroes in-between.
{
b=2*a;
c=1+2*a;
X[b]=x[a];
X[c]=0;
}
for (a=2*M; a<2*N; a++) //Appends the additional zeroes on to the end. Note that this is both the real and imaginary elements
{
X[a]=0;
}
float* w =(float*)malloc(sizeof(float)*M); //"w," twiddle-factor container, must be defined in this way since its length depends on a variable
gen_w_r2(w,N); //Twiddle factor generation; function prototyped and included below
//------ACTUAL FFT HERE:----------------
bit_rev(w, N >> 1);
DSPF_sp_cfftr2_dit(X,w,N);
bit_rev(X,N);
/* These to bits (bit_rev & 'for' loop) are the parts that make the 'raw' outputs look like the Matlab outputs. To
* re-include them in the code to be compiled, simply remove the comments around them. */
for (a=0;a<2*N;a=a+2)
{
x[a+1]=-x[a+1];
}
//--------------------------------------
}
void fft_Npt_DiT(int *input, double *X_out, double *Y_out,int N)
{
int i,j,k;
int offset=0;
int Set_Count=1;
double theta = 2*pi/N;
double X_in[1024],Y_in[1024];
double X_temp[3],Y_temp[3];
for(i=0;i<N;i++){
j = bit_rev(i,N);
X_in[j]=(double)input[i];
Y_in[j]=0;
}
for(i=N/2;i>=1;i=i/2){
offset = 0;
for(j=0;j<N/(i*2);j++){
for(k=0;k<i;k++){
X_temp[0] = X_in[k+offset]+X_in[k+i+offset];
Y_temp[0] = Y_in[k+offset]+Y_in[k+i+offset];
X_temp[1] = X_in[k+offset]-X_in[k+i+offset];
Y_temp[1] = Y_in[k+offset]-Y_in[k+i+offset];
X_temp[2] = (X_temp[1]*cos(theta*Set_Count*k)) + (Y_temp[1]*sin(theta*Set_Count*k));
Y_temp[2] = (-(X_temp[1]*sin(theta*Set_Count*k))) + (Y_temp[1]*cos(theta*Set_Count*k));
X_in[k+offset] = X_temp[0];
Y_in[k+offset] = Y_temp[0];
X_in[k+i+offset] = X_temp[2];
Y_in[k+i+offset] = Y_temp[2];
}
offset +=i*2;
}
Set_Count = Set_Count*2;
printf("---------\n");
}
}
void main(void)
{
float A[128] = {43.000000,0.000000, 3.616321,30.125547, -14.479670,-2.567202, 12.362492,-21.842867, 32.385956,13.828468, -7.707342,18.480019, 1.519983,-3.868871, 4.327905,-4.279924, 20.798990,2.485281, 2.305606,11.042850, 16.090977,2.064070, 5.466386,19.738562, 0.345887,10.251665, -3.438493,4.526769, 12.931265,9.287642, -14.795074,12.285769, 17.000000,-10.000000, 4.956760,30.588863, -4.126019,7.640384, -12.621098,21.370527, -6.488023,-10.174742, 1.631006,20.984383, -14.443722,-3.912756, 6.433661,14.007210, -18.798990,14.485281, -23.586613,0.723100, -5.995662,-12.674122, -23.052052,8.538252, -10.243816,-50.597946, 35.359089,3.127013, 8.502851,-7.042882, 24.741423,53.781017, -81.000000,0.000000, 24.741428,53.781006, 8.502846,-7.042882, 35.359089,3.127012, -10.243820,-50.597939, -23.052046,8.538255, -5.995665,-12.674120, -23.586613,0.723101, -18.798990,14.485281, 6.433663,14.007207, -14.443724,-3.912753, 1.631013,20.984381, -6.488022,-10.174742, -12.621092,21.370529, -4.126016,7.640386, 4.956764,30.588863, 17.000000,-10.000000, -14.795071,12.285774, 12.931269,9.287637, -3.438493,4.526770, 0.345886,10.251665, 5.466391,19.738560, 16.090977,2.064065, 2.305608,11.042850, 20.798990,2.485281, 4.327904,-4.279922, 1.519982,-3.868872, -7.707339,18.480021, 32.385952,13.828463, 12.362488,-21.842869, -14.479672,-2.567199, 3.616327,30.125546};
unsigned short N=64; //There're 64 complex numbers in A, taking up 128 array entries.
//PRINT FFT'd VALUES (inputs)
printf("Original Inputs (Results of an FFT w/ Post-Processing (a-la Matlab):");
printf("\n");
int i;
int a;
for(i=0;i<N;i=i+2)
{
printf("%f",A[i]);
printf(" ");
printf("%f i",A[i+1]);
printf("\n");
}
printf("\n");
float* w =(float*)malloc(sizeof(float)*(N/2));
gen_w_r2(w,N);
bit_rev(w, N>>1 );
printf("\n");
//"Fixing" the FFT results; I.E. undoing post-processing----------------
for (a=0;a<N;a=a+2)
{
A[a+1]=-A[a+1];
}
bit_rev(A,N);
//----------------------------------------------------------------------
printf("FFT'd Results, WITHOUT Post-Processing");
printf("\n");
for (i=0;i<N;i=i+2)
{
printf("%f",A[i]);
printf(" ");
printf("%f",A[i+1]);
printf(" i;");
printf("\n");
}
printf("\n");
//IFFT here:
DSPF_sp_icfftr2_dif(A,w,N);
//Scale by N
for (i = 0; i < N*2; i++) /*ACHTUNG! Originally the limiting condition was "i < N*2" because "N" represents the number of COMPLEX
numbers in the array; since it takes two array entries (real & imaginary) to represent one complex\
number, the array is twice as long as this "N." If there's a problem with the IFFT, consider changing
this first to see if anything's solved.*/
{
A[i] /= N;
}
printf("IFFT'd Final Outputs");
printf("\n");
//PRINT IFFT'd VALUES (OUTPUTS)
for (i=0;i<N;i=i+2)
{
printf("%f",A[i]);
printf(" ");
printf("%f",A[i+1]);
printf(" i;");
printf("\n");
}
//Now we should have no complex values, so even indices of Y are real-valued and odd (cpx) indices or Y are zeroes. We now chop out
//these interstitial zeroes
float* y =(float*)malloc(sizeof(float)*((N/2)-1));
for (i=0; i<N;i++)
{
y[i]=A[2*i];
}
}
/* Autocorrelation-based LPC analysis
Performs the LPC analysis on a given frame... returns the lpc coefficients
Input arguments
xx: input buffer pointer
aa: LPC coefficients pointer (output)
size: size of the input buffer (xx)
nlpc: LPC order, i.e., number of LPC coefficients
SC (2008/05/06): Incoroporating cepstral lifting */
void LPFormantTracker::getAi(dtype* xx, dtype* aa) {
int i0;
//dtype temp_frame[maxBufLen + maxNLPC]; // Utility buffer for various filtering operations
//dtype R[maxNLPC]; // lpc fit Autocorrelation estimate
int nlpcplus1 = nLPC + 1;
for(i0 = 0; i0 < nlpcplus1; i0++)
temp_frame[i0] = 0;
// Window input
//SC vecmu1: vector multiply
//SC hwin: a Hanning window
DSPF_dp_vecmul(xx, winFunc, &temp_frame[nlpcplus1], bufferSize); // Apply a Hanning window
// TODO: Check temp_frame size
////////////////////////////////////////////////////
//SC(2008/05/07) ----- Cepstral lifting -----
if (bCepsLift){
for (i0=0;i0<nFFT;i0++){
if (i0 < bufferSize){
ftBuf1[i0 * 2] = temp_frame[nlpcplus1 + i0];
ftBuf1[i0 * 2 + 1]=0;
}
else{
ftBuf1[i0 * 2] = 0;
ftBuf1[i0 * 2 + 1] = 0;
}
}
DSPF_dp_cfftr2(nFFT, ftBuf1, fftc, 1);
bit_rev(ftBuf1, nFFT);
// Now ftBuf1 is X
for (i0 = 0; i0 < nFFT; i0++){
if (i0 <= nFFT / 2){
ftBuf2[i0 * 2] = log(sqrt(ftBuf1[i0*2]*ftBuf1[i0*2]+ftBuf1[i0*2+1]*ftBuf1[i0*2+1])); // Optimize
ftBuf2[i0 * 2 + 1]=0;
}
else{
ftBuf2[i0 * 2] = ftBuf2[(nFFT - i0) * 2];
ftBuf2[i0 * 2 + 1]=0;
}
}
DSPF_dp_icfftr2(nFFT, ftBuf2, fftc, 1);
bit_rev(ftBuf2, nFFT);
// Now ftBuf2 is Xceps: the cepstrum
for (i0 = 0; i0 < nFFT; i0++){
if (i0 < cepsWinWidth || i0 > nFFT - cepsWinWidth){ // Adjust!
ftBuf1[i0 * 2] = ftBuf2[i0 * 2] / nFFT; // Normlize the result of the previous IFFT
ftBuf1[i0 * 2 + 1] = 0;
}
else{
ftBuf1[i0 * 2] = 0;
ftBuf1[i0 * 2 + 1] = 0;
}
}
// Now ftBuf1 is Xcepw: the windowed cepstrum
DSPF_dp_cfftr2(nFFT,ftBuf1,fftc,1);
bit_rev(ftBuf1,nFFT);
for (i0=0;i0<nFFT;i0++){
if (i0<=nFFT/2){
ftBuf2[i0*2]=exp(ftBuf1[i0*2]);
ftBuf2[i0*2+1]=0;
}
else{
ftBuf2[i0*2]=ftBuf2[(nFFT-i0)*2];
ftBuf2[i0*2+1]=0;
}
}
DSPF_dp_icfftr2(nFFT,ftBuf2,fftc,1); // Need normalization
bit_rev(ftBuf2,nFFT);
for (i0 = 0; i0 < bufferSize / 2; i0++){
temp_frame[nlpcplus1 + bufferSize / 2 + i0] = ftBuf2[i0 * 2] / nFFT;
}
for (i0 = 1; i0 < bufferSize / 2; i0++){
temp_frame[nlpcplus1 + bufferSize / 2 - i0] = ftBuf2[i0 * 2] / nFFT;
}
temp_frame[nlpcplus1] = 0.0;
}
//~SC(2008/05/07) ----- Cepstral lifting -----
///////////////////////////////////////////////////////////
// Find autocorrelation values
DSPF_dp_autocor(R, temp_frame, bufferSize, nlpcplus1); //SC Get LPC coefficients by autocorrelation
// Get unbiased autocorrelation
for(i0 = 0; i0 < nlpcplus1; i0++)
R[i0] /= bufferSize;
// levinson recursion
levinson(R, aa, nlpcplus1);
}
int str_match(const char *str, const char *format) {
const char *s = str;
const char *fmt = format;
unsigned int flag = 0;
int width = 0;
bit_t bit;
char c;
const char *s0;
while (*fmt) {
if (*fmt == '%') {
fmt++;
while (*fmt >= '0' && *fmt <= '9')
width = width * 10 + *fmt++ - '0';
switch(*fmt) {
case 'd':
if (width) {
while (*s && isdigit(*s) && width-- > 0)
s++;
} else {
while (*s && isdigit(*s))
s++;
}
fmt++;
break;
case '[':
fmt++;
bit_zero(&bit);
if (*fmt == '^') {
fmt++;
flag |= STATUS_CARET;
}
while (*fmt && *fmt != ']') {
if (fmt[1] == '-') {
for (c = *fmt; c < fmt[2]; c++) {
bit_set(&bit, c);
}
if (c == fmt[2])
fmt += 2;
} else {
bit_set(&bit, *fmt);
fmt++;
}
}
if (flag & STATUS_CARET) {
bit_rev(&bit);
/* clear STATUS_CARET */
flag &= ~STATUS_CARET;
}
if (width) {
while (*s && bit_isset(&bit, *s) && width-- > 0) {
s++;
}
} else {
while (*s && bit_isset(&bit, *s)) {
s++;
}
}
if (*fmt == ']')
fmt++;
break;
case 'f':
if (width) {
while (*s && isdigit(*s) && width > 0)
s++, width--;
if (*s == '.' && width > 0)
s++, width--;
while (*s && isdigit(*s) && width > 0)
s++, width--;
} else {
while (*s && isdigit(*s))
s++;
if (*s == '.')
s++;
while (*s && isdigit(*s))
s++;
}
fmt++;
break;
case '{':
fmt++;
flag &= ~STATUS_OR;
while(*fmt && *fmt != '|' && *fmt != '}') {
s0 = s;
/* match */
while (*fmt && *fmt != '|' && *fmt != '}' && (*s0 == *fmt))
s0++, fmt++;
/* match ok*/
if (*fmt == '|' || *fmt == '}') {
flag |= STATUS_OR;
while (*fmt && *fmt != '}')
fmt++;
s = s0;
} else {
/* match no*/
while (*fmt && *fmt != '|' && *fmt != '}')
fmt++;
if (*fmt == '|' || *fmt == '}')
fmt++;
}
}
if (!(flag & STATUS_OR))
return 0;
if (*fmt == '}')
fmt++;
break;
default:
fmt++;
break;
}
width = 0;
} else {
/*printf("%d:%d:%c:%c\n", *fmt, *s, *fmt, *s);*/
if (!*fmt && !*s)
return 1;
if (*fmt != *s) {
/* %?*/
if (*fmt && fmt[1] == '%' && fmt[2] == '?') {
fmt++;
continue;
}
else
return 0;
}
fmt++;
s++;
}
}
return !*fmt && !*s;
}
