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);
}