commonopt.h

跨操作系统的微型中间件

#ifndef _COM_OPT_H_FILE_923klsdfkl34__
#define _COM_OPT_H_FILE_923klsdfkl34__

#include "OSHeaders.h"
#include "MyAssert.h"
#include <list>
#include <string>

#ifdef WIN32
#pragma warning(disable:4786)
#endif

#ifndef _PACKET_TYPE 
#define _PACKET_TYPE   1
enum PACKET_TYPE
{
	DTYPE_NONE = 0,
	DTYPE_RTSP = 1,
	DTYPE_RTP  = 2,
	DTYPE_RTCP = 4,
	DTYPE_RDT = 6
};
#endif

Bool ParserURL(const std::string &vURL, std::string &outIP, UInt16 &outPort);
Bool ReplaceIpInURL(std::string &vURL, std::string inIP );
std::string GetMovieName(const std::string &vURL);
void CloseSocket(int fd);

Bool ParserRMPacket(char* inPacket,UInt32 inLen,UInt8* outFlag1,UInt16* outSeqNo,UInt8* outFlag2,
					UInt32* outTS,UInt32* outLen,UInt16 inPayload =0xFFFF);
Bool ParserRTPPacket(char* inPacket,UInt32 inLen,UInt16& outSeqNo,UInt32& outTS);
Bool ModifyRTPPacket(char* inPacket,UInt32 inLen,UInt16 inSeqNo,UInt32 inTS);

class CTimeStampExt
{
public:
	CTimeStampExt(){Reset();};
	~CTimeStampExt(){};
	
	void Reset(){m_uiLastTimeStampExt = 0;m_uiLastTimeStamp = 0;m_bSetLastTimeStamp = FALSE;}
	void ConvertTimeStampToUI64(UInt64& TimeStamp);
	
protected:
	Bool IsSetLastTimeStampFlag(){return m_bSetLastTimeStamp;}
	void SetLastTimeStampFlag(){m_bSetLastTimeStamp = TRUE;}
	UInt64 GetLastTimeStampExt(){return m_uiLastTimeStampExt;}
	void  SetLastTimeStampExt( UInt64 TimeStampExt ){m_uiLastTimeStampExt = TimeStampExt;}
	UInt64 GetLastTimeStamp(){return m_uiLastTimeStamp;}
	void  SetLastTimeStamp( UInt32 TimeStamp ){m_uiLastTimeStamp = TimeStamp;}
	
private:
	UInt64   m_uiLastTimeStampExt;
	UInt32    m_uiLastTimeStamp;
	Bool     m_bSetLastTimeStamp;
	
};


//////////////////////////////////////////////////////////////////////////


#endif


#ifndef  __RTPSORTCONTAINER_H__
#define  __RTPSORTCONTAINER_H__

#define  INVALID_VALUE  0xFFFFFFFF

#define  OS_ERR_STREAM_JUMP     0x8888

typedef  struct _RTP_SORT
{
	char        *pData;
	UInt16       len;
	UInt64       timestamp;
}RTP_SORT;

typedef std::list<RTP_SORT> RTP_SORT_VEC;

class CRtpAlloctor
{
public:
	CRtpAlloctor();
	~CRtpAlloctor();
	
	RTP_SORT Alloctor();
	void Reclaim(RTP_SORT);
	void Reset();
private:
	RTP_SORT_VEC   m_lsContainer;
};

typedef std::list<RTP_SORT> RTP_BUF_LIST;
class CRtpContainer
{
private:
	RTP_BUF_LIST   m_lsUsedRtpBuf;
	CRtpAlloctor   m_alloc;
public:
	CRtpContainer(){;};
	~CRtpContainer();
	
	void Reset()
	{
		RTP_BUF_LIST::iterator it = m_lsUsedRtpBuf.begin();
		while( it != m_lsUsedRtpBuf.end() )
		{
			m_alloc.Reclaim(*it);
			it ++;
		}
		m_lsUsedRtpBuf.clear();
	};
	
	RTP_SORT* Alloc()
	{ 
		m_lsUsedRtpBuf.push_back(m_alloc.Alloctor());
		return &(*(--m_lsUsedRtpBuf.end()));
	};
	
	UInt64      Free(UInt64 vStart, UInt64 vEnd) ;// FREE [vStart,vEnd)
};

#define  SORT_BUF_TIME  3  // buf 3 seconds rtp data

class CRtpSortContainer
{
public:
	CRtpSortContainer(){ reset();}
	~CRtpSortContainer();
	
	void ClearBuf();
	
	void reset();
	
	void Reclaim(RTP_SORT item)
	{
		if( item.pData )
			delete [] item.pData;
		item.pData=0;
	};
	void SetBufLen(unsigned int ts,unsigned int timescale=0){m_uiBufLen=ts;m_timescale=timescale;};
	void SetStreamType(UInt32 st) {m_uiStreamType = st;};
	
	OS_Error Flow(const char*,UInt16 len,PACKET_TYPE dt,RTP_SORT*);
	OS_Error  PushPacket(const char*,UInt16 len,PACKET_TYPE dt); // push a rtp packet to sort buf
	OS_Error PopPacket(RTP_SORT*);      // pop a rtp packet from sort buf
	void PrintAllBuf();
	
private:
	UInt64  GetMinTimeStamp();
	UInt64  GetMaxTimeStamp();
	const char* GetBiggestPacketData();
	
	void    Sort(const RTP_SORT item);
	
private:
	RTP_SORT_VEC   m_vecRtp;
	CRtpAlloctor   m_alloctor;
	
	unsigned int   m_uiBufLen; // ms,cache n milinseconds data.
	
	Bool           m_bRecvFirstPacket;
	UInt32         m_uiStreamType;
	
	UInt32         m_timescale;
	
};
#endif


#ifndef  __CTSCONVERT_H__
#define  __CTSCONVERT_H__
#include <map>

#ifndef _RTPHEADER_
#define _RTPHEADER_  1
struct tagRTPHEADER
{
	UInt16	Flag;
	UInt16	SeqNo;
	UInt32	TimeStamp;
};
#endif
#define MAX_SAME_TRACKID  3
class CTSConvert
{
private:
	class TRACK
	{
		friend class CTSConvert;
	public:
		TRACK()
		{
			ResetParam();
			
			uiSameTrackNum = 0;
		}
		void ResetParam(){uiFstTStamp  =  INVALID_VALUE;uiTimeOffset  = INVALID_VALUE;};
	private:
		UInt32	uiTimeScale;
		UInt32  uiSameTrack[MAX_SAME_TRACKID];
		UInt32  uiSameTrackNum;
		
		Int64	uiFstTStamp;
		Int64	uiTimeOffset;
		
		CTimeStampExt	m_TsConverters;
	};
	
	typedef   std::map<UInt32,TRACK>   MAPTRACK;	
	
	public:
		CTSConvert();
		~CTSConvert()
		{
			Reset();
		};
		
		Bool  AddTrack(UInt32 uiTrackID,UInt32 uiTS,Bool bBase,UInt32* pSameTrack=0,UInt32 uiSameNum=0);
		
		OS_Error  ConvertRTP(UInt32 uiTrackID,char* pRtpData,UInt16 uiLen,PACKET_TYPE dt,UInt64& ms);
		
		void  Reset() { m_mapTrack.clear();m_uiBaseTrackID = INVALID_VALUE;};
		void  ResetParam();    // 重置用来计算多路流时间偏差的参数
		
	private:
		OS_Error AdjustRtpTimestamp(UInt32 vTrackID,TRACK *pTrackInfo,char *pRtpData,PACKET_TYPE dt,UInt64& rstpTimeStamp);
		CTSConvert::TRACK* FindTrackInfo(UInt32 vTrackID);
	private:	
		MAPTRACK   m_mapTrack;
		
		UInt32	     m_uiBaseTrackID;
};


//打包，和解包
class PacketHandler
{
	enum 	Mode{ READ, WRITE};
	
	UInt32	m_Offset;
	UInt32	m_MaxBuffLen;
	char*		m_pBuffer;
	Mode		m_Mode;
	Bool		m_HasErr;	
	
public:
	PacketHandler(char *pBuff, UInt32 vBuffLen)
	{
		m_Offset = 0;
		m_MaxBuffLen = vBuffLen;
		m_pBuffer = pBuff;
		m_Mode = WRITE;
		m_HasErr = FALSE;
	}
	PacketHandler(const char *pBuff, UInt32 vBuffLen)
	{
		m_Offset = 0;
		m_MaxBuffLen = vBuffLen;
		m_pBuffer = (char *)pBuff;
		m_Mode = READ;
	}
	UInt32	Size() { return m_Offset; }
	Bool		HasErr() { return m_HasErr; }
	
	//组包函数
	PacketHandler& operator <<(UInt8 vData);
	PacketHandler& operator <<(UInt16 vData);
	PacketHandler& operator <<(UInt32 vData);
	PacketHandler& operator <<(UInt64 vData);
	PacketHandler& PutString(const char *pData, UInt32 vLen);
	
	//解包函数
	PacketHandler& operator >>(UInt8 & vData);
	PacketHandler& operator >>(UInt16 & vData);
	PacketHandler& operator >>(UInt32 & vData);
	PacketHandler& operator >>(UInt64 & vData);
	PacketHandler& GetString(UInt32 vLen,std::string &outStr);
	PacketHandler& GetString(char *pBuff,UInt32 vBuffLen);
};

/*
 *	统计有多少位SET/CLR
 */

enum STATISTIC_METHOD { SET_BIT = 0, CLR_BIT = 1};
UInt32	StatisticBits(UInt8 *pData, UInt32 vLen, STATISTIC_METHOD vMethod = SET_BIT);

#endif