lpc.c

用DSP实现的一个简单的语音识别系统

#include <math.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "lpc.h"

#define FRAMELEN		240		//帧长
#define FRAMESHIFT		80		//帧移
#define LPCFACTOR		10		//lpc阶数
#define LPCCFACTOR		10		//lpcc阶数
#define REALMAX			100000000

//////////////////////////////////////////////////////////////////
///		函数功能：计算lpc系数		
///		参数含义：	fData----一帧数据，输入参数
///					fResult---返回结果，输出参数
//////////////////////////////////////////////////////////////////
void lpc(float* fData, float* fResult)
{
	int i,j,k;
	float r[LPCFACTOR+1];
	float l[LPCFACTOR];
	float a[LPCFACTOR][LPCFACTOR];
	float e[LPCFACTOR];
	float c[LPCFACTOR];
	float d[LPCFACTOR];
		
	for(i=0; i<LPCFACTOR+1; i++)
	{
		float sum=0.0;
		for(j=0; j<FRAMELEN-i; j++)
		{
			sum += (*(fData+j)) * (*(fData+j+i));
		}
		*(r+i) = sum;
	}


	l[0] = r[1]/r[0];
	a[0][0] = l[0];
	e[0] = (1-squre(l[0]))*r[0];
	
	for(i=1; i<LPCFACTOR; i++)
	{
		float sum=0.0;
		for(j=0; j<i; j++)
		{
			sum += (a[i-1][j])*(r[i-j]);
		}
		c[i] = sum;
		l[i] = (r[i+1]-c[i])/e[i-1];
		a[i][i] = l[i];
		for(j=0; j<i; j++)
		{
			a[i][j] = a[i-1][j]-l[i]*a[i-1][i-j-1];
		}
		e[i] = (1-squre(l[i]))*e[i-1];
	}
	for(k=0; k<LPCFACTOR; k++)
	{
		d[k] = a[LPCFACTOR-1][k];
		d[k] = (-1)*d[k];
	}
	memcpy(fResult, d, sizeof(float)*LPCFACTOR);
	return;
}


/////////////////////////////////////////////////////////////////
//		函数功能：由lpc得到lpcc
//		参数含义：	lpcdata---lpc系数所在的内存首地址,输入参数
//					lpccdata---返回的lpcc系数，输出参数
/////////////////////////////////////////////////////////////////
void lpctolpcc(float* lpcdata, float* lpccdata)
{
	int m,k;
	float sum=0.0;
	float tempData[LPCCFACTOR];
	for(m=0; m<LPCFACTOR; m++)
	{
		sum = *(lpcdata+m);
		for(k=0; k<m; k++)
		{
			sum += (*(lpcdata+k))*tempData[m-k-1]*(1.0-(float)(k+1)/(m+1));
		}
		tempData[m]=sum;
	}
	for(m=LPCFACTOR; m<LPCCFACTOR; m++)
	{
		sum=0.0;
		for(k=0; k<LPCFACTOR; k++)
		{
			sum += (*(lpcdata+k))*tempData[m-k-1]*(1.0-(float)(k+1)/(m+1));
		}
		tempData[m]=sum;
	}
	memcpy(lpccdata, tempData, sizeof(float)*LPCCFACTOR);
	return;
}

////////////////////////////////////////////////////////////////////////////////////
//		函数功能：对模板参数和样本参数进行dtw比较
//		参数含义：	mobandata---模板参数数组，输入参数，大小为mbfrmcnt*LPCCFACTOR
//					yangbendata---样本参数数组，输入参数，大小为ybfrmcnt*LPCCFACTOR
//					mbfrmcnt---模板的帧数，输入参数
//					ybfrmcnt---样本帧数，输入参数
//					cmpresult---比较结果，输出参数，大小为mbfrmcnt*ybfrmcnt
////////////////////////////////////////////////////////////////////////////////////
float dtw(float* mobandata, float* yangbendata, int mbfrmcnt, int ybfrmcnt)
{
	int i,j,k;
	float sum,d1,d2,d3,retvalue;
	float paccd[50][50];
	//生成帧匹配距离矩阵
	float pd[50][50];
//	float* pd = (float*)malloc(sizeof(float)*mbfrmcnt*ybfrmcnt);
	for(i=0; i<mbfrmcnt; i++)
	{
		for(j=0; j<ybfrmcnt; j++)
		{
			sum=0.0;
			for(k=0; k<LPCCFACTOR; k++)
			{
				sum += squre((*(mobandata+i*LPCCFACTOR+k))-(*(yangbendata+j*LPCCFACTOR+k)));
			}
			pd[i][j]=sum;
//			*(pd+i*ybfrmcnt+j) = sum;
		}
	}

	//
//	paccd = (float*)malloc(sizeof(float)*mbfrmcnt*ybfrmcnt);
	paccd[0][0]=pd[0][0];
//	*paccd = *pd;
	
	//动态规划
	for(i=1; i<mbfrmcnt; i++)
	{
		for(j=0; j<ybfrmcnt; j++)
		{
			d1 = paccd[i-1][j];
//			d1 = *(paccd+(i-1)*ybfrmcnt+j);
			if(j>0)
				d2 = paccd[i-1][j-1];
//				d2 = *(paccd+(i-1)*ybfrmcnt+j-1);
			else
				d2 = REALMAX;

			if(j>1)
				d3=paccd[i-1][j-2];
//				d3 = *(paccd+(i-1)*ybfrmcnt+j-2);
			else
				d3 = REALMAX;

			paccd[i][j]=pd[i][j]+min(d1,d2,d3);
//			*(paccd+i*ybfrmcnt+j) = *(pd+i*ybfrmcnt+j) + min(d1, d2, d3);
		}
	}
	retvalue = paccd[mbfrmcnt-1][ybfrmcnt-1];
//	retvalue = *(paccd+mbfrmcnt*ybfrmcnt-1);
//	free(pd);
//	free(paccd);
	return retvalue;
}


float squre(float b)
{
	return b*b;
}
float min(float f1, float f2, float f3)
{
	float temp;
	if(f1<0)
		f1*=-1;
	if(f2<0)
		f2*=-1;
	if(f3<0)
		f3*=-1;
		
	temp=f1;
	if(f2<temp)
		temp=f2;
	if(f3<temp)
		temp=f3;
	return temp;
}