lanaudio.h

G711语音压缩源码

// LanAudio.h: interface for the CLanAudio class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_LANAUDIO_H__F79CFD70_AFE8_11D2_B7C8_444553540000__INCLUDED_)
#define AFX_LANAUDIO_H__F79CFD70_AFE8_11D2_B7C8_444553540000__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

typedef int          BOOL;
#ifndef FALSE
#define FALSE               0
#endif
#ifndef TRUE
#define TRUE                1
#endif


#define  Frame       240
#define  G711_Frame  160
#define  LpcFrame    180
#define  SubFrames   4
#define  SubFrLen    (Frame/SubFrames)

#define  LpcOrder          10
#define LpcOrderP1         (LpcOrder+1)

#define  PitchMin          18
#define  PitchMax          (PitchMin+127)

#define SizErr              5

#define NbAvAcf            3  // Nb of frames for Acf average               
#define NbAvGain           3  // Nb of frames for gain average              
#define SizAcf             ((NbAvAcf+1)*LpcOrderP1) // size of array Acf    

struct CODSTATDEF
{
	// High pass variables 
	float    HpfZdl;
	float    HpfPdl;

	// Lsp previos vector 
	float   PrevLsp[LpcOrder];

	// All pitch operation buffers 
	float    PrevWgt[PitchMax];
	float    PrevErr[PitchMax];
	float    PrevExc[PitchMax];

	// Requered memory for the delay 
	float   PrevDat[LpcFrame-SubFrLen];

	// Used delay lines 
	float    WghtFirDl[LpcOrder];
	float    WghtIirDl[LpcOrder];
	float    RingFirDl[LpcOrder];
	float    RingIirDl[LpcOrder];

	// For taming procedure 
	short   SinDet;
	float    Err[SizErr];
};

struct DECSTATDEF
{
	int     Ecount;
	float   InterGain;
	short  InterIndx;
	short  Rseed;
	float   Park;
	float   Gain;

	// Lsp previous vector 
	float   PrevLsp[LpcOrder];

	// All pitch operation buffers 
	float   PrevExc[PitchMax];

	// Used delay lines 
	float   SyntIirDl[LpcOrder];
	float   PostFirDl[LpcOrder];
	float   PostIirDl[LpcOrder];
};

// harmonic noise shaping filter parameters
struct PWDEF
{
	int   Indx;
	float Gain;
};

// subframe coded parameters 
struct SFSDEF
{
	int      AcLg;
	int      AcGn;
	int      Mamp;
	int      Grid;
	int      Tran;
	int      Pamp;
	int   Ppos;
};

// frame coded parameters 
struct LINEDEF
{
	short   Crc;
	int   LspId;
	int      Olp[SubFrames/2];
	SFSDEF   Sfs[SubFrames];
};

// Coder part 
struct CODCNGDEF
{
	float   CurGain;
	short  PastFtyp;
	float   Acf[SizAcf];
	float   LspSid[LpcOrder];
	float   SidLpc[LpcOrder];
	float   RC[LpcOrderP1];
	float   Ener[NbAvGain];
	short  NbEner;
	short  IRef;
	float   SidGain;
	short  RandSeed;
};

// Decoder part 
struct DECCNGDEF
{
	float   CurGain;
	short  PastFtyp;
	float   LspSid[LpcOrder];
	float   SidGain;
	short  RandSeed;
};

// VAD static variables
struct VADSTATDEF
{
	short  Hcnt;
	short  Vcnt;
	float Penr;
	float Nlev;
	short  Aen;
	short  Polp[4];
	float NLpc[LpcOrder];
};

// pitch postfilter parameters 
struct PFDEF
{
	int     Indx;
	float   Gain;
	float   ScGn;
};

typedef enum tagEAudioCodec{
		G711_A,
		G711_U,
		G723
	}EAudioCodec;
//class  AFX_EXT_CLASS CLanAudioEncoder
class  CLanAudioEncoder
{
public:
	CLanAudioEncoder(int iBitRate = 0, BOOL bHighPassFilter = TRUE, BOOL bVad = TRUE,EAudioCodec nCodec=G723);
					// 6.3k highpass vad default
	virtual ~CLanAudioEncoder();

	int Encode(const short * iFrame, char * cCode);
	void Mute() { m_bMute = TRUE; };
	void Unmute(){ m_bMute = FALSE; };
protected:
	int EncodeG711(const short *iFrame,unsigned char *cCode);
	int EncodeG723(const short * iFrame, char * cCode);

	short random_number(short np1, short *nRandom);
	void  Upd_Ring(float *Dpnt, float *QntLpc, float *PerLpc, float *PrevErr);
	void  Sub_Ring(float *Dpnt, float *QntLpc, float *PerLpc, float *PrevErr, PWDEF Pw);
	void  Error_Wght(float *Dpnt, float *PerLpc);
	void  Comp_Lpc(float *UnqLpc, float *PrevDat, float *DataBuff);
	void  Calc_Exc_Rand(float curGain, float *PrevExc, float *DataExc, short *nRandom, LINEDEF *Line);
	void  Decod_Acbk(float *Tv, float *PrevExc, int Olp, int Lid, int Gid);
	void  Find_Acbk(float *Tv, float *ImpResp, float *PrevExc, LINEDEF *Line, int Sfc);
	int   Test_Err(int Lag1, int Lag2);
	void  Update_Err(int Olp, int AcLg, int AcGn);
	int   ACELP_LBC_code(float X[], float h[], int T0, float code[], int *ind_gain, int *shift, int *sign, float gain_T0);
	int   D4i64_LBC(float Dn[], float rr[], float h[], float cod[], float y[], int *code_shift, int *sign);
	void  Find_Fcbk(float *Dpnt, float *ImpResp, LINEDEF *Line, int Sfc);
	void  Line_Pack(LINEDEF *Line, char *Vout, short Ftyp);
	void  Rem_Dc(float *Dpnt);
	BOOL  LpcDiff(float *RC, float *ptrAcf, float alpha);
	void  CalcRC(float *Coeff, float *RC);
	void  ComputePastAvFilter(float *Coeff);
	void  Update_Acf(float *Acf_sf);
	BOOL  Comp_Vad(float *Dpnt);
	void  Cod_Cng(float *DataExc, short *Ftyp, LINEDEF *Line, float *QntLpc);
	BOOL  Coder(float *DataBuff, char *Vout);
	void  reset_max_time(void);
	void  Init_Cod_Cng(void);
	void  Init_Vad(void);
	void  Init_Coder(void);

protected:
	BOOL UseHp;
	BOOL UseVx;
	int  WrkRate;
	int  extra;
	float DataBuff[Frame];
	CODCNGDEF  CodCng;
	VADSTATDEF VadStat;
	CODSTATDEF CodStat;
	EAudioCodec	m_nCodec;
	BOOL   m_bMute;//TRUE，对进行静音处理，否则不进行静音处理
};

//class AFX_EXT_CLASS CLanAudioDecoder  
class  CLanAudioDecoder  
{
public:
	CLanAudioDecoder(BOOL bPostFilter = TRUE,EAudioCodec nCodec=G723);
	virtual ~CLanAudioDecoder();

	int Decode(short * iFrame, char * cCode);
	void Mute() { m_bMute = TRUE; };
	void Unmute(){ m_bMute = FALSE; };
protected:
	int DecodeG711(unsigned char* input,short *decode);
	int DecodeG723(short* iFrame, char* cCode);

	short  random_number(short np1, short *nRandom);
	float Spf(float *Tv, float *Lpc);
	void   Synt(float *Dpnt, float *Lpc);
	PFDEF  Comp_Lpf(float *Buff, int Olp, int Sfc);
	PFDEF  Get_Ind(int Ind, float Ten, float Ccr, float Enr);
	void   Calc_Exc_Rand(float curGain, float *PrevExc, float *DataExc, short *nRandom, LINEDEF *Line);
	void   Decod_Acbk(float *Tv, float *PrevExc, int Olp, int Lid, int Gid);
	void   Fcbk_Unpk(float *Tv, SFSDEF Sfs, int Olp, int Sfc);
	void   Scale(float *Tv, float Sen);
	LINEDEF Line_Unpk(char *Vinp, short *Ftyp, short Crc);
	void   Dec_Cng(short Ftyp, LINEDEF *Line, float *DataExc, float *QntLpc);
	BOOL   Decod(float *DataBuff, char *Vinp, short Crc);
	void   Init_Dec_Cng(void);
	void   Init_Decod(void);

protected:
	DECCNGDEF  DecCng;
	DECSTATDEF DecStat;
	float DataBuff[Frame];
	BOOL UsePf;
	int  WrkRate;
	EAudioCodec m_nCodec;
	BOOL   m_bMute;//TRUE，对进行静音处理，否则不进行静音处理
};

#endif // !defined(AFX_LANAUDIO_H__F79CFD70_AFE8_11D2_B7C8_444553540000__INCLUDED_)