Scribd
Upload
26 views

Listing Program Visual C

This document contains the source code for a program written in Visual C++ that performs speech signal processing and feature extraction. The code includes functions for input/output, front-end processing, framing, windowing, fast Fourier transform (FFT), liftering, logarithm, and cepstrum computation. It reads in an audio signal, segments it into frames, applies signal processing techniques to each frame to extract features, and writes the results to output files at each step for analysis and verification.

Uploaded by

Rif Setyanto
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
26 views

Listing Program Visual C

This document contains the source code for a program written in Visual C++ that performs speech signal processing and feature extraction. The code includes functions for input/output, front-end processing, framing, windowing, fast Fourier transform (FFT), liftering, logarithm, and cepstrum computation. It reads in an audio signal, segments it into frames, applies signal processing techniques to each frame to extract features, and writes the results to output files at each step for analysis and verification.

Uploaded by

Rif Setyanto
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

LISTING PROGRAM VISUAL C++

#include <math.h>
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include "snack.h"

#define Pangkat 9
#define nlpc 256
#define inv 1.0f
#define inv2 -1.0f

static float G[300][300];


static float st_CEP[300][16];
static float in_CEP[300][16];

static int st_blk,in_blk;

float DP_match1(int);
float distance(int,int);

void trace();

/**********front-end**********/

int front_end_clip(xx,yy,jml_sin)
float *xx,*yy;
int jml_sin;
{
int i,mulai,akhir,jml_sin_new;
float jml=0,mean,dev,jumdev=0,sd,batas;

for(i=0;i<jml_sin;i++)
jml+=xx[i];
mean=jml/jml_sin;
for(i=0;i<jml_sin;i++)
{
dev=(float)fabs(xx[i]-mean);
jumdev+=dev*dev;
}
sd=(float)sqrt(jumdev/jml_sin);
batas=mean+3*sd;
for(i=0;i<jml_sin;i++)
{
if(xx[i]>=batas)
{
mulai=i;
break;
}
}
for(i=jml_sin;i>0;i--)
{
if(xx[i]>=batas)
{
akhir=i;
break;
}
}
jml_sin_new=0;
for(i=mulai;i<akhir;i++)
{
yy[jml_sin_new]=xx[i];
jml_sin_new++;
}
return(jml_sin_new);
}

/********* Start Input********/

FILE *fsignal,*finfo,*fframe,*fsignalframe,*fpower,*fhamm,*ffft,*flift,*flog,*fceps;
Sound *sound;

double temp_log1;
float x[30000],y[30000],temp[30000];

float real[512],imag[512];
float ms,spd;
int k,frame,frame_no,signal_length,signal_length_new,start;

void hammr();
void cal_fft();

int Input(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj*CONST objv[])


{
fsignal=fopen(".\\input\\sampling_in.txt","w");
finfo=fopen(".\\input\\front_end_in.txt","w");
fframe=fopen(".\\input\\frame_in.txt","w");
fsignalframe=fopen(".\\input\\signalframe_in.txt","w");
fhamm=fopen(".\\input\\hamming_in.txt","w");
ffft=fopen(".\\input\\fft_in.txt","w");
flift=fopen(".\\input\\liftering_in.txt","w");
flog=fopen(".\\input\\log_in.txt","w");
fceps=fopen(".\\input\\cepstrum_in.txt","w");

/************ Get the sound structure for this sound ************/


sound = Snack_GetSound(interp,Tcl_GetStringFromObj(objv[0], NULL));
signal_length = Snack_GetLength(sound);
for (k=0;k<signal_length;k++)
{
x[k]=(float)Snack_GetSample(sound, 0, k);
fprintf(fsignal,"%f\n",x[k]); // Sampling Process
}

/********** Frame Blocking **********/

signal_length_new = front_end_clip(x,&y,signal_length);
for (k=0;k<signal_length_new;k++)
fprintf(finfo,"%f\n",y[k]);//front-end detection process

frame_no = signal_length_new/120;
fprintf(fframe,"%d\n",frame_no);

start=0;
ms=0;
spd=(float)10/240;

for(frame=0;frame<frame_no-1;frame++)
{
start=(frame)*120;
for(k=0;k<240;k++)
{
temp[k]=y[start];
fprintf(fsignalframe,"%f\n",temp[k]); //frame blocking process
start++;
}
}
for(frame=0;frame<frame_no-1;frame++)
{
for (k=0;k<240;k++)
{
real[k]=temp[k];
imag[k]=0;
}

/********** Hamming Window *********/

hammr(real,imag,nlpc);
for(k=0;k<240;k++)
fprintf(fhamm,"%f\t%f\n",ms=ms+spd,real[k]); //Windowing
process
for(k=240;k<512;k++)
{
real[k]=0;
imag[k]=0;
}

/************* FFT (Fast Fourier Transform) ************/

cal_fft(real,imag,pangkat,inv);

/********* Magnitude FFT ******/

for(k=0;k<512;k++)
{
temp_log1=(double)(real[k]*real[k]+imag[k]*imag[k]);
if(temp_log1>0)
real[k]=(float)log10(temp_log1);
else
real[k]=(float)log10(0.000001);
imag[k]=0;
fprintf(ffft,"%f\t%f\n",k*6000.f/256.f,real[k]); // FFT (Fast
Fourier Transform) Process
}

/************* IFFT (Invers Fast Fourier Transform) ***********/

cal_fft(real,imag,pangkat,inv2); // IFFT (Invers Fast Fourier Transform)


grafik tidak ditampilkan

/********* Liftering (Cepatral Window) *********/

for(k=16;k<512-16;k++)
{
real[k]=0.0;
imag[k]=0.0;
}
for(k=0;k<256;k++)
fprintf(flift,"%f\t%f\n",ms=ms+spd,real[k]); // Liftering Process

/********** Mutlak Log (Data Sample yg diambil) *********/

for(k=0;k<256;k++)
{
temp_log1=(double)(real[k]*real[k]+imag[k]*imag[k]);
if(temp_log1>0)
real[k]=(float)log10(temp_log1);
else
real[k]=(float)log10(0.000001);
imag[k]=0;
fprintf(flog,"%f\n",real[k]); // Mutlak Log
}
/********** Cepstrum *********/
cal_fft(real,imag,pangkat,inv);
for(k=0;k<256;k++)
{
temp_log1=(double)(real[k]*real[k]+imag[k]*imag[k]);
if(temp_log1>0)
real[k]=(float)log10(temp_log1);
else
real[k]=(float)log10(0.000001);
imag[k]=0;
fprintf(fceps,"%f\n"/*,k*6000.f/256.f*/,real[k]); // Cepstrum
Process
}
}

fclose(fsignal);
fclose(finfo);
fclose(fframe);
fclose(fsignalframe);
fclose(fhamm);
fclose(ffft);
fclose(flift);
fclose(flog);
fclose(fceps);

return TCL_OK;

/********* Pengolahan Sinyal Dtbase *********/

FILE*fsignal,*finfo,*fframe,*fsignalframe,*fpower,*fhamm,*ffft,*flift,*flog,*fceps;
Sound *sound;

double temp_log1;
float x[30000],y[30000],temp[30000];
float real[512],imag[512];
float ms,spd;
int k,frame,frame_no,signal_length,signal_length_new,start;

void hammr();
void cal_fft();

int Dtbase(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj*CONST objv[])


{
fsignal=fopen(".\\standart\\sampling_n.txt","w");
finfo=fopen(".\\standart\\front_end_n.txt","w");
fframe=fopen(".\\standart\\frame_n.txt","w");
fsignalframe=fopen(".\\standart\\signalframe_n.txt","w");
fhamm=fopen(".\\standart\\hamming_n.txt","w");
ffft=fopen(".\\standart\\fft_n.txt","w");
flift=fopen(".\\standart\\liftering_n.txt","w");
flog=fopen(".\\standart\\magnitudeFFT_n.txt","w");
fceps=fopen(".\\standart\\cepstrum_n.txt","w");

/****** Get the sound structure for this sound ******/

sound = Snack_GetSound(interp,Tcl_GetStringFromObj(objv[0], NULL));


signal_length = Snack_GetLength(sound);

for (k=0;k<signal_length;k++)
{
x[k]=(float)Snack_GetSample(sound, 0, k);
fprintf(fsignal,"%f\n",x[k]); // Sampling Process
}

/********** Frame Blocking **********/

signal_length_new = front_end_clip(x,&y,signal_length);
for (k=0;k<signal_length_new;k++)
fprintf(finfo,"%f\n",y[k]); // Front-End Process

frame_no = signal_length_new/120;
fprintf(fframe,"%d\n",frame_no);

start=0;
ms=0;
spd=(float)10/240;

for(frame=0;frame<frame_no-1;frame++)
{
start=(frame)*120;
for(k=0;k<240;k++)
{
temp[k]=y[start];
fprintf(fsignalframe,"%f\n",temp[k]); // Frame Blocking Process
start++;
}
}
for(frame=0;frame<frame_no-1;frame++)
{
for (k=0;k<240;k++)
{
real[k]=temp[k];
imag[k]=0;
}
}

/***** hamming window *****/


hammr(real,imag,nlpc);
for(k=0;k<240;k++)
fprintf(fhamm,"%f\t%f\n",ms=ms+spd,real[k]); // Windowing Process
for(k=240;k<512;k++)
{
real[k]=0;
imag[k]=0;
}

/********** FFT (Fast Fourier Transform) *********/

cal_fft(real,imag,pangkat, beki,inv);

/***** Magnitude FFT *****/

for(k=0;k<512;k++)
{
temp_log1=(double)(real[k]*real[k]+imag[k]*imag[k]);
if(temp_log1>0)
real[k]=(float)log10(temp_log1);
else
real[k]=(float)log10(0.000001);
imag[k]=0;
fprintf(ffft,"%f\t%f\n",k*6000.f/256.f,real[k]); // FFT (Fast Fourier
Transform) Process
}

/*********** IFFT (Invers Fast Fourier Transform **********/

cal_fft(real,imag,pangkat,inv2); // Grafik tidak ditampilkan

/********** Liftering **********/

for(k=16;k<512-16;k++)
{
real[k]=0.0;
imag[k]=0.0;
}
for(k=0;k<256;k++)
fprintf(flift,"%f\t%f\n",ms=ms+spd,real[k]); // Liftering Process

/***** Mutlak Log (Data Sample yg diambil) *****/

for(k=0;k<256;k++)
{
temp_log1=(double)(real[k]*real[k]+imag[k]*imag[k]);
if(temp_log1>0)
real[k]=(float)log10(temp_log1);
else
real[k]=(float)log10(0.000001);
imag[k]=0;
fprintf(flog,"%f\n",real[k]);// Mutlak Log Process
}

/************** Cepstrum **********/

cal_fft(real,imag,beki,inv);
for(k=0;k<256;k++)
{
temp_log1=(double)(real[k]*real[k]+imag[k]*imag[k]);
if(temp_log1>0)
real[k]=(float)log10(temp_log1);
else
real[k]=(float)log10(0.000001);
imag[k]=0;
fprintf(fceps,"%f\n"/*,k*6000.f/256.f*/,real[k]); // Cepstrum Process
}

fclose(fsignal);
fclose(finfo);
fclose(fframe);
fclose(fsignalframe);
fclose(fhamm);
fclose(ffft);
fclose(flift);
fclose(flog);
fclose(fceps);

return TCL_OK;
}

int Dtw(ClientData cdata, Tcl_Interp *interp, int objc, Tcl_Obj*CONST objv[])

{
FILE *fin,*fstd1,*fstd2,*fstd3,*fstd4,*fstd5;
FILE *fframe,*fout1,*fout2,*ftrace1,*ftrace;

int i,j,r;
static int out=1;
float DP_dist,hasil[5],rata,rata1,min,in;

float in_data,std_data_1,std_data_2,std_data_3,std_data_4,std_data_5;
float in_in,in_1,in_2,in_3,in_4,in_5;

fin=fopen(".\\input\\cepstrum_in.txt","r");
fstd1=fopen(".\\standart\\cepstrum_power.txt","r");
fstd2=fopen(".\\standart\\cepstrum_elka.txt","r");
fstd3=fopen(".\\standart\\cepstrum_telkom.txt","r");
fstd4=fopen(".\\standart\\cepstrum_kontrol.txt","r");
fstd5=fopen(".\\standart\\cepstrum_ti.txt","r");

fout1=fopen(".\\hasil\\out1.txt","w");
fout2=fopen(".\\hasil\\out.txt","w");
ftrace=fopen(".\\hasil\\rata1.txt","w");
ftrace1=fopen(".\\hasil\\in.txt","w");

/****** sinyal input *********/

fframe=fopen(".\\input\\frame_in.txt","r");
fscanf(fframe,"%d\n",&in_blk);
fclose(fframe);
for(i=0;i<in_blk;i++)
{
for(j=0;j<10;j++)
{
fscanf(fin,"%f\t%f\n",&in_in,&in_data); // Masukkan Sinyal
Input
in_CEP[i][j]=in_data;
}
}

/***** Menghitung jarak antara sinyal input dan standar Power *****/

fframe=fopen(".\\standart\\frame_power.txt","r");
fscanf(fframe,"%d\n",&st_blk);
fclose(fframe);
for(i=0;i<st_blk;i++)
{
for(j=0;j<10;j++)
{
fscanf(fstd1,"%f\t%f\n",&in_1,&std_data_1);
st_CEP[i][j]=std_data_1;
}
}
r=7;
DP_dist=DP_match1(r);
hasil[1]=DP_dist;

/***** Menghitung jarak antara sinyal input dan standar Elka *****/

fframe=fopen(".\\standart\\frame_elka.txt","r");
fscanf(fframe,"%d\n",&st_blk);
fclose(fframe);
for(i=0;i<st_blk;i++)
{
for(j=0;j<10;j++)
{
fscanf(fstd2,"%f\t%f\n",&in_2,&std_data_2);
st_CEP[i][j]=std_data_2;
}
}
r=7;
DP_dist=DP_match1(r);
hasil[2]=DP_dist;

/***** Menghitung jarak antara sinyal input dan standar Telkom *****/

fframe=fopen(".\\standart\\frame_telkom.txt","r");
fscanf(fframe,"%d\n",&st_blk);
fclose(fframe);
for(i=0;i<st_blk;i++)
{
for(j=0;j<10;j++)
{
fscanf(fstd3,"%f\t%f\n",&in_3,&std_data_3);
st_CEP[i][j]=std_data_3;
}
}
r=7;
DP_dist=DP_match1(r);
hasil[3]=DP_dist;

/***** Menghitung jarak antara sinyal input dan standar Kontrol *****/

fframe=fopen(".\\standart\\frame_kontrol.txt","r");
fscanf(fframe,"%d\n",&st_blk);
fclose(fframe);
for(i=0;i<st_blk;i++)
{
for(j=0;j<10;j++)
{
fscanf(fstd4,"%f\t%f\n",&in_4,&std_data_4);
st_CEP[i][j]=std_data_4;
}
}
r=7;
DP_dist=DP_match1(r);
hasil[4]=DP_dist;

/***** Menghitung jarak antara sinyal input dan standar TI *****/

fframe=fopen(".\\standart\\frame_ti.txt","r");
fscanf(fframe,"%d\n",&st_blk);
fclose(fframe);
for(i=0;i<st_blk;i++)
{
for(j=0;j<10;j++)
{
fscanf(fstd5,"%f\t%f\n",&in_5,&std_data_5);
st_CEP[i][j]=std_data_5;
}
}
r=7;
DP_dist=DP_match1(r);
hasil[5]=DP_dist;

/***********output**************/

for(i=1;i<=5;i++)
fprintf(fout1,"%f\n",hasil[i]);

min=hasil[1];
for(i=1;i<=5;i++)
{
if(min>=hasil[i])
{
min=hasil[i];
out=i;
}
}
rata=0;
for(i=1;i<=5;i++)
{
rata+=hasil[i];
}
rata1=rata/5;
in=hasil[out];
fprintf(ftrace1,"%f\n",in);
fprintf(ftrace,"%f\n",rata1);
fprintf(fout2,"%d\n",out);

fclose(fin);
fclose(fout1);
fclose(fout2);
fclose(fstd1);
fclose(fstd2);
fclose(fstd3);
fclose(fstd4);
fclose(fstd5);
fclose(ftrace);
fclose(ftrace1);

return TCL_OK;
}
/******* Inisialisasi ***********/

EXPORT(int, Baru_Init)(Tcl_Interp *interp)


{
#ifdef USE_TCL_STUBS
if (Tcl_InitStubs(interp, "8", 0) == NULL) {return TCL_ERROR;
}
#endif
#ifdef USE_SNACK_STUBS
if (Snack_InitStubs(interp, "2", 0) == NULL) {return TCL_ERROR;
}
#endif
if (Tcl_PkgProvide(interp, "baru", "1.0") != TCL_OK) {return TCL_ERROR;
}

Snack_AddSubCmd(SNACK_SOUND_CMD, "Input",(Snack_CmdProc *)
Input, NULL);
Snack_AddSubCmd(SNACK_SOUND_CMD, "Dtbase",(Snack_CmdProc *)
Dtbase, NULL);
Snack_AddSubCmd(SNACK_SOUND_CMD, "Dtw",(Snack_CmdProc *) Dtw,
NULL);

return TCL_OK;
}

EXPORT(int, Baru_SafeInit)(Tcl_Interp *interp)


{
return Baru_Init(interp);
}
#ifdef __cplusplus
#endif

void hammr(x,y,n)
float *x,*y;
int n;
{
int i;
--x;
--y;
for(i=0;i<=n;++i)
{
x[i]=x[i]*(float)(0.54-0.46*cos(2.0*3.141592654*(i)/(float)n));
y[i]=y[i]*(float)(0.54-0.46*cos(2.0*3.141592654*(i)/(float)n));
}
}

void cal_fft(x,y,l,mode)
float *x,*y,mode;
int l;
{
int np,lmx,lo,lix,lm,li,j1,j2,nv2,npm1,i,j,k;
float scl,arg,c,s,t1,t2;
for(i=0;i<pow(2,l);i++)
y[i]=0;
--x;
--y;

/* ====== radix-2 fft ====== */

np=(int)pow(2.0,(float)(l));
lmx=np;
scl=(float)(6.283185303/(float)np);
for(lo=1;lo<=l;++lo)
{
lix=lmx;
lmx=(int)(lmx/2.0);
arg=0.0;
for(lm=1;lm<=lmx;++lm)
{
c=(float)cos(arg);
s=(float)(mode*sin(arg));
arg=arg+scl;
for (li=lix; lix<0 ? li>=np : li<=np; li+=lix)
{
j1=li-lix+lm;
j2=j1+lmx;
t1=x[j1]-x[j2];
t2=y[j1]-y[j2];
x[j1]=x[j1]+x[j2];
y[j1]=y[j1]+y[j2];
x[j2]=c*t1+s*t2;
y[j2]=c*t2-s*t1;
}
}
scl=(float)(2.0*scl);
}

/* ====== bit reversal ====== */

j=1;
nv2=(int)(np/2.0);
npm1=np-1;
for(i=1;i<=npm1;++i)
{
if(i>=j)
goto L30;
t1=x[j];
t2=y[j];
x[j]=x[i];
y[j]=y[i];
x[i]=t1;
y[i]=t2;
L30:
k=nv2;
L40:
if(k>=j)
goto L50;
j-=k;
k=(int)(k/2.0);
goto L40;
L50:
j=j+k;
}
}

/***********DTW********/

float DP_match1(r)
int r;
{
int i,j;
int I,J,up,dp;
float dist,g,g0,g1,g2,g3,a;
float DP_mdist=0.0;
for(i=0;i<in_blk;i++)
{
for(j=0;j<st_blk;j++)
{
G[i][j] = (float)1.0e+30;
}
}
I=in_blk-1;
J=st_blk-1;
a=(float)st_blk/(float)in_blk;
dist=distance(0,0);
G[0][0]=(float)(2.0*dist);
dist=0.0;
for(i=0;i<=I;i++)
{
up=(int)(a*i+r);
if(up>J)
up=J;
dp=(int)(a*i-r);
if(dp<0)
dp=0;
for(j=dp;j<=up;j++)
{
if(i==0 && j==0)
j++;
g0=(float)1.0e+30;
g1=(float)1.0e+30;
g2=(float)1.0e+30;
dist = distance(i,j);
if(j-1>=0)
g0 = (float)(G[i][j-1]+dist);
if(i-1>=0 && j-1>=0)
g1 = (float)(G[i-1][j-1]+2.0*dist);
if(i-1>=0)
g2 = (float)(G[i-1][j]+dist);
g3 = (g0<g1) ? g0:g1;
g = (g2<g3) ? g2:g3;
G[i][j] = g;
}
}
DP_mdist = G[I][J]/(st_blk+in_blk);
return(DP_mdist);
}
float distance(ab_t,ab_r)
int ab_t,ab_r;
{
int i;
float a,kyori;
a=0.0;
kyori=0.0;
for(i=0;i<11;i++)
{
a=(in_CEP[ab_t][i]-st_CEP[ab_r][i]);
kyori+=a*a;
}
return(kyori);
}

You might also like