commonopt.cpp

跨操作系统的微型中间件

	item.timestamp = ts;
	item.len = len;
	memcpy(item.pData,pData,len);
	Sort(item);
	
	return OS_NoErr;
}

// the container have data like this: 64,43,22,22,13,12,5,5,5,1,
void CRtpSortContainer::Sort(const RTP_SORT item)
{
	static int s_add = 0;	
	RTP_SORT_VEC::iterator it = m_vecRtp.begin();
	
	Int32  iDelta = 0;
	
	for( ;it!=m_vecRtp.end();it++)
	{
		iDelta = (Int32)item.timestamp - (Int32)(it->timestamp);
		
		if( iDelta > 0  )
		{
			m_vecRtp.insert(it,item);
			return;
		}
		else
		{
			///TODO 对相同的TimeStamp需要对SeqNo进行排序
		}
	}
	m_vecRtp.push_back(item);
	
}
void CRtpSortContainer::PrintAllBuf()
{
	RTP_SORT_VEC::reverse_iterator it = m_vecRtp.rbegin();
	UInt32 ts,seqno;
	printf( "Start dump ....\n" );
	
	for( ;it!=m_vecRtp.rend();it++)
	{
		char * pData = (*it).pData;
		if( pData )
		{
			tagRTPHEADER* pRtpHeader = (tagRTPHEADER*)pData;
			ts = ntohl(pRtpHeader->TimeStamp);
			seqno = ntohs( pRtpHeader->SeqNo );
		}
		printf("[seqno:%u,timestamp:%u]!\n",seqno,ts);
	}
	printf( "End dump ....\n" );
	
}

// 用BUF SIZE来确定乱续区间,
OS_Error CRtpSortContainer::PopPacket(RTP_SORT* pItem)
{
	Assert( m_vecRtp.size()!=0 && m_uiBufLen );
	Int32 iRange = (Int32)GetMaxTimeStamp() - (Int32)GetMinTimeStamp();
	
	if( iRange > m_uiBufLen )
	{
		RTP_SORT item = m_vecRtp.back();
		m_vecRtp.pop_back();
		*pItem = item;
		return OS_NoErr;
	}
	return OS_Err;
}

UInt64 CRtpSortContainer::GetMinTimeStamp()
{
	if( m_vecRtp.size()>0 )
	{
		return m_vecRtp.back().timestamp;
	}
	return 0;
}
const char* CRtpSortContainer::GetBiggestPacketData()
{
	if( m_vecRtp.size() > 0 )
	{
		return m_vecRtp.front().pData;
	}
	return 0;
}

UInt64 CRtpSortContainer::GetMaxTimeStamp()
{
	if( m_vecRtp.size() > 0 )
	{
		return m_vecRtp.front().timestamp;
	}
	return 0;
}

#define  MAX_RTP_BUF 1600
CRtpAlloctor::CRtpAlloctor()
{
	;
}
CRtpAlloctor::~CRtpAlloctor()
{
	Reset();
}

RTP_SORT CRtpAlloctor::Alloctor()
{
	if( m_lsContainer.size() <=0 )
	{
		RTP_SORT  item;
		item.pData = new char[MAX_RTP_BUF];
		item.len = 0;
		item.timestamp=0;
		return item;
	}
	else
	{
		RTP_SORT item = m_lsContainer.front();
		m_lsContainer.pop_front();
		return item;
	}
}
void CRtpAlloctor::Reclaim(RTP_SORT item)
{
	if( item.pData )
	{
		item.len = 0;
		item.timestamp =0;
		m_lsContainer.push_back(item);
	}
}


void CRtpAlloctor::Reset()
{
	RTP_SORT_VEC::iterator it = m_lsContainer.begin();
	for(;it!=m_lsContainer.end();it++)
	{
		if( it->pData )
		{
			delete it->pData;
			it->pData = 0;
		}
	}
	m_lsContainer.clear();
	
}
// 注意，必须等RTP BUFFER中的包发送后才可以被析构
CRtpContainer::~CRtpContainer()
{
	Reset();
};

UInt64  CRtpContainer::Free(UInt64 vStart, UInt64 vEnd) // FREE [vStart,vEnd)
{
	UInt64 end = vStart;
	RTP_BUF_LIST::iterator it,itNext = m_lsUsedRtpBuf.begin();
	while( itNext!= m_lsUsedRtpBuf.end() )
	{
		it = itNext++;
		if( (*it).timestamp>=vStart && (*it).timestamp<vEnd )
		{
			end = (*it).timestamp;
			m_alloc.Reclaim(*it);
			m_lsUsedRtpBuf.erase(it);
		}
	}
	return end;
}

///////////////////////////////////////////////////////////////////////////////////
#define NET_ORDER

//字节序转换
#ifdef NET_ORDER
#define ORDEROUT16(a) htons(a)
#define ORDEROUT32(a) htonl(a)
UInt64 ORDEROUT64(UInt64 vData)
{
	UInt64 iOut = 0;
	UInt8 *pData = (UInt8 *)&iOut;
	for(Int32 i = 7; i>= 0 ; i--)
	{
		pData[7- i] = (UInt8)(vData >> i*8);
	}
	return iOut;
}

#define ORDERIN16(a) ntohs(a)
#define ORDERIN32(a) ntohl(a)
UInt64 ORDERIN64(UInt64 vData) 
{
	UInt64 iOut = 0;
	UInt8 *pData = (UInt8 *)&vData;
	for(Int32 i = 7; i>= 0 ; i--)
	{
		iOut += (UInt64)(pData[7-i]) << i*8;
	}
	return iOut;
}

#else

#define ORDEROUT16(a) a
#define ORDEROUT32(a) a
#define ORDEROUT64(a) a

#define ORDERIN16(a) a
#define ORDERIN32(a) a
#define ORDERIN64(a) a
#endif

PacketHandler & PacketHandler::operator <<( UInt8 vData )
{
	Assert(m_Mode == WRITE);
	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		*(m_pBuffer + m_Offset) = (char)vData;
		m_Offset += sizeof(UInt8);
	}
	return *this;
}

PacketHandler & PacketHandler::operator <<( UInt16 vData )
{
	Assert(m_Mode == WRITE);
	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		UInt16 iTmp = ORDEROUT16(vData);
		memcpy(m_pBuffer + m_Offset, &iTmp, sizeof(vData));
		m_Offset += sizeof(vData);
	}
	else
		m_HasErr = TRUE;
	return *this;
}

PacketHandler & PacketHandler::operator <<( UInt32 vData )
{
	Assert(m_Mode == WRITE);
	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		UInt32 iTmp = ORDEROUT32(vData);
		memcpy(m_pBuffer + m_Offset, &iTmp, sizeof(vData));
		m_Offset += sizeof(vData);
	}
	else
		m_HasErr = TRUE;
	return *this;
}

PacketHandler & PacketHandler::operator <<( UInt64 vData )
{
	Assert(m_Mode == WRITE);
	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		UInt64 iTmp = ORDEROUT64(vData);
		memcpy(m_pBuffer + m_Offset, &iTmp, sizeof(vData));
		m_Offset += sizeof(vData);
	}
	else
		m_HasErr = TRUE;
	return *this;
}

PacketHandler& PacketHandler::PutString(const char *pData, UInt32 vLen)
{
	Assert(m_Mode == WRITE);
	Assert(m_Offset + vLen <= m_MaxBuffLen);
	if(m_Offset + vLen <= m_MaxBuffLen)
	{
		memcpy(m_pBuffer + m_Offset, pData, vLen);
		m_Offset += vLen;
	}
	else
		m_HasErr = TRUE;
	return *this;
}

PacketHandler & PacketHandler::operator >>( UInt8 & vData )
{
	Assert(m_Mode == READ);
	//	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	//	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		vData = (UInt8)(*(m_pBuffer + m_Offset));
		m_Offset += sizeof(UInt8);
	}
	//	else
	//		m_HasErr = TRUE;
	return *this;
}

PacketHandler & PacketHandler::operator >>( UInt16 & vData )
{
	Assert(m_Mode == READ);
	//	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	//	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		vData = ORDERIN16(*(UInt16*)(m_pBuffer + m_Offset));
		m_Offset += sizeof(vData);
	}
	//	else
	//		m_HasErr = TRUE;
	return *this;
}

PacketHandler & PacketHandler::operator >>( UInt32 & vData )
{
	Assert(m_Mode == READ);
	//	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	//	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		vData = ORDERIN32(*(UInt32*)(m_pBuffer + m_Offset));
		m_Offset += sizeof(vData);
	}
	//	else
	//		m_HasErr = TRUE;
	return *this;
}

PacketHandler & PacketHandler::operator >>( UInt64 & vData )
{
	Assert(m_Mode == READ);
	//	Assert(m_Offset + sizeof(vData) <= m_MaxBuffLen);
	//	if(m_Offset + sizeof(vData) <= m_MaxBuffLen)
	{
		vData = ORDERIN64(*(UInt64*)(m_pBuffer + m_Offset));
		m_Offset += sizeof(vData);
	}
	//	else
	//		m_HasErr = TRUE;
	return *this;
}

PacketHandler& PacketHandler::GetString(UInt32 vLen,std::string &outStr)
{
	Assert(m_Mode == READ);
	//	Assert(m_Offset + vLen <= m_MaxBuffLen);
	//	if(m_Offset + vLen <= m_MaxBuffLen)
	{
		outStr.assign(m_pBuffer + m_Offset, vLen);
		m_Offset += vLen;
	}
	//	else
	//		m_HasErr = TRUE;
	return *this;
}

PacketHandler & PacketHandler::GetString( char * pBuff, UInt32 vBuffLen )
{
	Assert(m_Mode == READ);
	//	Assert(m_Offset + vBuffLen <= m_MaxBuffLen);
	//	if(m_Offset + vBuffLen <= m_MaxBuffLen)
	{
		memcpy(pBuff, m_pBuffer + m_Offset, vBuffLen);
		m_Offset += vBuffLen;
	}
	//	else
	//		m_HasErr = TRUE;
	return *this;
}

//////////////////////////////////////////////////////////////////////////////////////////
UInt32	StatisticBits(UInt8 *pData, UInt32 vLen, STATISTIC_METHOD vMethod)
{
	if(!pData || vLen == 0)
		return 0;

	UInt32 iCount = 0;
	if(vMethod == SET_BIT)
	{
		//测试通过
		for(UInt32 i = 0; i < vLen; i++)
		{
			UInt8 iMask = 0x1;
			for(UInt32 j = 0 ;j < 8; j++)
			{
				if((iMask & pData[i]) != 0)
					iCount++;
				iMask <<= 1;
			}
		}
	}
	else
	{
		///TODO 未经过测试
		for(UInt32 i = 0; i < vLen; i++)
		{
			UInt8 iMask = 0x1;
			for(UInt32 j = 0 ;j < 8; j++)
			{
				if((iMask & pData[i]) == 0)
					iCount++;
				iMask <<= 1;
			}
		}
	}
	
	return iCount;
}