dsp.h

实现了精简的FFT语音压缩 采取了一种新的算法有一定的参考价值

// DSP.h: interface for the DSP class.
//////////////////////////////////////////////////////////////////////

#ifndef _DSP_CLASS
#define _DSP_CLASS

#include <string>
#include <fstream.h>
#include <deque>
#include <math.h>

#ifndef AFX_EXT_CLASS
#define AFX_EXT_CLASS
#endif

#include "StdAfx.h"

#ifdef UNIX_SYSTEM_
	#define TRUE			1
	#define	FALSE			0

	#ifndef BOOL
		typedef BYTE			BOOL;
	#endif
	#ifndef DWORD
		typedef unsigned long	DWORD;
	#endif
	#ifndef BYTE
		typedef unsigned char	BYTE;
	#endif
	#ifndef SOCKET
		typedef int				SOCKET;
	#endif
#endif

#define SECT_MAX_SIZE	0xFFF			//分段传送时段的最大尺寸

class AFX_EXT_CLASS DSPACT;

#define SELF_SERIALIZE(classid,className,base_className) \
	public: \
		virtual char* GetClassID()		{return classid;} \
		virtual bool  IsKindOf(char* lpClassName){return (::strcmp(className,lpClassName)==0);}\
	protected: \
		virtual BYTE  GetClassLevel()	{return (base_className::GetClassLevel()+1);} \


#define DSPGETOBJFUNC(varN)		DSPACT* (*varN)(const std::string& strID)		
#define CASTDSPGETOBJFUNC		DSPACT* (*)(const std::string& strID)		

#define DSPSECTRECV(varN)		bool (*varN)(const char* const lpBuff,int nBuffLen,bool bLast)
#define CASTDSPSECTRECV			bool (*)(const char* const lpBuff,int nBuffLen,bool bLast)

#define DSPSECTSEND(varN)		bool (*varN)(char** const lpBuff,int& nBuffLen,bool& bContinue)
#define CASTDSPSECTSEND			bool (*)(char** const lpBuff,int& nBuffLen,bool& bContinue)

#define	DSPCOMPRESSFUNC(varN)	bool (*varN)(char** const lpBuff,int& nBuffLen)
#define	CASTDSPCOMPRESSFUNC		bool (*)(char** const lpBuff,int& nBuffLen)

#define DSPUNCOMPRESSFUNC(varN)	bool (*varN)(char** const lpBuff,int& nBuffLen,bool bStart)
#define CASTDSPUNCOMPRESSFUNC	bool (*)(char** const lpBuff,int& nBuffLen,bool bStart)
	

class AFX_EXT_CLASS DSP  
{
public:
	struct AFX_EXT_CLASS _DSPPACKET;
private:
	DSP(){};
	~DSP(){};
	friend struct _DSPPACKET;
	struct _DSPHEADER;
	struct _DSPATTRHEADER;
	struct _DSPVALUEHEADER;
	struct _DSPACTREG;
	static std::deque<_DSPACTREG*>	dqActReg;

	static inline DSP::_DSPACTREG*	FindClassID(const std::string& strID);
	static inline DSPACT*			GetDSPObject(std::string& strID,DWORD& dwData);
	static inline WORD				CheckSumAttr(const char *lpHead,const char *lpTail);

public:
	enum _DSPERRTYPE
	{
		ERR_RECV_HEADER			=10000,
		ERR_FIND_HEADER,
		ERR_RECV_ATTRHEADER,
		ERR_VERIFY_ATTRHEADER,
		ERR_RECV_CLASSID,
		ERR_NOTGET_DSPACT,
		ERR_RECV_ATTRSIZE,
		ERR_SET_ATTR_BUFF,
		ERR_UNCOMPRESS,
		ERR_RECV_ATTR_SECT,
		ERR_RECV_ATTRVALUE,
		ERR_RECV_PACKETCRC,
		ERR_RECV_PACKET_CRC,
		ERR_RECV_NAME,

		ERR_SEND_HEADER			=11000,
		ERR_SEND_ATTRHEADER,
		ERR_SEND_CLASSID,
		ERR_SERIALIZE_ATTR,
		ERR_SEND_ATTR_SECT,
		ERR_SEND_ATTRSIZE,
		ERR_SEND_ATTRVALUE,
		ERR_SEND_PACKETCRC,
		ERR_SEND_NAME,
		ERR_COMPRESS,
	};

	struct AFX_EXT_CLASS _DSPERROR
	{
		BYTE			byClassLevel;			//类深度
		DWORD			dwAttrNo;				//属性个数编号
		int				nErrorNo;				//错误代码
		std::string		strErrDetail;			//错误描述
	};

	struct AFX_EXT_CLASS _DSPPACKET
	{
		//DSP包结构
		timeval			Timeout;				//接收Socket时的超时时间
		DWORD			dwData;					//在注册类时指定的该类的附加数据
		bool&			bKeepRun;				//是否继续运行，通过这个布尔变量，可以随时中止序列化或反序列化过程
		
	private:
		_DSPERROR		LastError;				//保存最近一个错误的描述
		char			chData1[6];
		char			chData2[2];
		char			chBuff[sizeof(DWORD)];	//保存临时数据的缓冲区
		char*			lpAttrBuff;				//接收属性的缓冲区的首地址
		std::string		strClassID;				//保存ClassID的值
		DWORD			dwAttrSize;				//当前接收缓冲区的长度
		WORD			wPacketCRC;				//包的总的CRC
		bool			bAttrRecvComplete;		//属性是否已经接收完成
		bool			bCompressAttr;			//属性是否被压缩
		DSPACT*			pDspAct;				//保存转换成对象后的基类对象的指针

		inline bool		FindHeader();
		inline bool		Recv(SOCKET sock,char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL);
		inline bool		Recv(ifstream& ifs,char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL);
		inline bool		Send(SOCKET sock,const char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL);
		inline bool		Send(ofstream& ofs,const char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL);
		inline bool		Recv(char** const lpUDPBuff,int& nUDPSize,char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL);
		inline bool		Send(char** const lpUDPBuff,int& nUDPSize,const char* const lpBuff,WORD wBuffLen,WORD* pCrc=NULL);

		inline DSPACT*	ReadError(_DSPERRTYPE errNo,BYTE classLevel,BYTE attrNo,DSPACT* pAct);
		inline bool		WriteError(_DSPERRTYPE errNo,BYTE classLevel,BYTE attrNo);
		inline bool		WriteObject(char** const lpUDPBuff,int& nUDPBuffLen,DSPACT& act);
		inline DSPACT*	ReadObjectFromIfs(ifstream& ifs,DSPACT* pAct);
		inline DSPACT*	ReadObjectFromTCP(SOCKET sock,DSPACT* pAct);
		inline DSPACT*	ReadObjectFromUDP(char** lpUDPBuff,int& nUDPBuffLen,DSPACT* pAct);
		inline DSPACT*	ReadObject(char** lpUDPBuff,int& nUDPBuffLen,DSPACT* pAct);

		inline bool		Serialize(SOCKET sock,const char* lpName,BYTE byNameLen,const char* lpValue,WORD usValueLen,bool bSendValueLen);
		inline bool		Serialize(ofstream& ofs,const char* lpName,BYTE byNameLen,const char* lpValue,WORD usValueLen,bool bSendValueLen);

	public:
		_DSPPACKET(bool& bRun):bKeepRun(bRun),dwAttrSize(0){Timeout.tv_sec=10;Timeout.tv_usec=0;};
		inline void	Empty()
		{
			pDspAct		=NULL;	
			dwAttrSize	=0;
			wPacketCRC	=0;
		};
		inline	_DSPERROR* const GetLastError(){return &LastError;};

		void	SetParameter(bool bCompress=false,bool bVerifyCRC=true,BYTE byInitType=0);
		bool	IsVerifyCrc();
		bool	IsCompress();
		DSPACT*	ReadObject(char* lpUDPBuff,int nUDPBuffLen,DSPACT* pAct=NULL);
		DSPACT*	ReadObject(SOCKET sock,DSPACT* pAct=NULL);
		DSPACT*	ReadObject(ifstream& ifs,DSPACT* pAct=NULL);
		bool	Read(char& attr);
		bool	Read(BYTE& attr);
		bool	Read(short& attr);
		bool	Read(WORD& attr);
		bool	Read(int& attr);
		bool	Read(DWORD& attr);
		bool	Read(bool& attr);
		bool	Read(std::string& attr,DWORD dwLen);
		bool	Read(char* const pAttr,DWORD dwLen);
		bool	Read(DSPACT& attr);

 inline	bool	WriteObject(SOCKET sock,sockaddr_in& to,char* const lpUDPBuff,int nUDPBuffLen,DSPACT& act);
		bool	WriteObject(SOCKET sock,sockaddr_in& to,int nUDPSize,DSPACT& act);
		bool	WriteObject(SOCKET sock,DSPACT& act);
		bool	WriteObject(ofstream& ofs,DSPACT& act);
		void	Write(int attr);
		void	Write(DWORD attr);
		void	Write(bool attr);
		void	Write(const std::string& attr);
		void	Write(char* const pAttr,DWORD dwLen,BOOL bLast=TRUE);
		void	Write(DSPACT& attr,bool bCompress=false,bool bVerifyCRC=true,BYTE byInitType=0);
		
		#ifndef	UNIX_SYSTEM_
			void	Write(const CString& attr);
			bool	Read(CString& attr,DWORD dwLen);
			bool	Serialize(const CString& strValue,const char* lpName=NULL,BYTE nNameLen=0);
			bool	UnSerialize(CString& strValue);
		#endif

		void	SerializeStart(ofstream& ofs,DSPCOMPRESSFUNC(pFun)=NULL);
		bool	Serialize(int nValue,const char* lpName=NULL,BYTE nNameLen=0);
		bool	Serialize(BYTE byValue,const char* lpName=NULL,BYTE nNameLen=0);
		bool	Serialize(bool bValue,const char* lpName=NULL,BYTE nNameLen=0);
		bool	Serialize(std::string& strValue,const char* lpName=NULL,BYTE nNameLen=0);
		bool	Serialize(char* lpBuff,int nBuffLen,const char* lpName=NULL,BYTE nNameLen=0,DSPSECTSEND(pFunc)=NULL);
		bool	Serialize(DSPACT& act,const char* lpName=NULL,BYTE nNameLen=0);
		bool	SerializeEnd();
		bool	UnSerializeStart(ifstream& ifs,DSPUNCOMPRESSFUNC(pFun)=NULL);
 inline	BYTE	IsKinkOf(std::string& strName);
 inline	bool	UnSerialize(DWORD& value,int& nValueLen);
		bool	UnSerialize(int& nValue);
		bool	UnSerialize(DWORD& dwValue);
		bool	UnSerialize(short& sValue);
		bool	UnSerialize(WORD& wValue);
		bool	UnSerialize(char& cValue);
		bool	UnSerialize(BYTE& byValue);
		bool	UnSerialize(std::string& strValue);
		bool	UnSerialize(char* pValue,int* nValueLen);
	};

	static bool		RegisterAct(const char* classID,DSPGETOBJFUNC(dspActFun),DWORD dwData=0);
	static SOCKET	ConnectTo(const char *lpSrvName,int nSrvPort,bool bInternet=true,int nRetryCount=5);
	static SOCKET	GetUDPSocket(int nListenPort=-1,bool bInternet=true);
	static SOCKET	GetTCPSocket(int nListenPort=-1,bool bInternet=true);
	static bool		GetAddrByName(const char *lpName,WORD port,sockaddr_in& addr);
	static void		GetAddrByIP(const char *lpIP,WORD port,sockaddr_in& addr,bool bInternet=true);
	static int		WaitRecvUDP(SOCKET sock,char *lpUDPBuff,int nUDPBuffLen,struct sockaddr_in& from,int nTimeoutSec=30);
	static DWORD	GetFileSize(const char* lpFilename);
	static DWORD	CreateNullFile(const char* lpFilename,int nSize,bool bAppend=true);
	static void		SafeRelease();

	static inline BOOL	OpenIfstreamForRead(ifstream& ifs,const char* const lpFileName,int nMode=0,int nShareMode=filebuf::openprot)
	{	ifs.open(lpFileName,ios::in|ios::binary|ios::nocreate|nMode,nShareMode);
		return ifs.is_open();
	};

	static inline BOOL	OpenOfstreamForWrite(ofstream& ofs,const char* const lpFileName,int nMode=0,int nShareMode=filebuf::sh_write||filebuf::sh_read)
	{	ofs.open(lpFileName,ios::out|ios::binary|nMode,nShareMode);
		return ofs.is_open();
	};
};


class AFX_EXT_CLASS DSPACT  
{
public:
	DSPACT(){};
	virtual ~DSPACT(){};
	virtual char *	GetClassID()=0;
	virtual bool	IsKindOf(char* lpClassName)=0;

protected:
	friend	struct	DSP::_DSPPACKET;
	virtual void	Init(BYTE byType){};
	virtual BYTE	GetClassLevel(){ return 0;	};
	virtual bool	AttrSectRecv(BYTE byClassLevels,BYTE byAttrNo,const char* const lpBuff,DWORD dwLen,bool bLast);
	virtual bool	AttrSectSend(BYTE byClassLevels,BYTE byAttrNo,char** const lpBuff,DWORD& dwLen,bool& bContinue);
	virtual bool	Serialize(BYTE byClassLevels,BYTE byAttrNo,DSP::_DSPPACKET &dsp);
	virtual bool	UnSerialize(BYTE byClassLevels,BYTE byAttrNo,DSP::_DSPPACKET &dsp,DWORD dwLen);
	virtual bool	Compress(char** const lpBuff,DWORD& dwLen);
	virtual bool	UnCompress(char** const lpBuff,DWORD dwLen,char* lpUnBuff,WORD& wUnLen,bool bStart);
};

#endif