cchannel.cpp

这是G.723和G.729的音频编解码的源代码

//CChannel.cpp

#include "stdafx.h"
#include "CChannel.h"

CPacket::CPacket(const CPacket& Packet)
{
	m_nLength=Packet.m_nLength;
	if(m_nLength)
	{
		m_pPacket=new BYTE[Packet.m_nLength];
		CopyMemory(m_pPacket,Packet.m_pPacket,Packet.m_nLength);
	}
	else
		m_pPacket=NULL;	
}

CPacket& CPacket::operator=(const CPacket& Packet)
{
	if(this!=&Packet)
	{
		if(m_pPacket)
			delete [] m_pPacket;

		m_nLength=Packet.m_nLength;
		if(m_nLength)
		{
			m_pPacket=new BYTE[Packet.m_nLength];
			CopyMemory(m_pPacket,Packet.m_pPacket,Packet.m_nLength);
		}
		else
			m_pPacket=NULL;
	}
	return *this;
}

//the begin of class CChannel
CChannel::CChannel(int nChannelNumber,int nPriority)
{
	m_nChannelNumber=nChannelNumber;	
	m_nPriority=nPriority;
}


//the begin of class CSendChannel
CSendChannel::CSendChannel(int nChannelNumber,int nPriority,int nMaxPacketLength)
						   :CChannel(nChannelNumber,nPriority)					   
{	
	m_nMaxPacketLength=nMaxPacketLength;

	m_nMaxPackedPacketLength=nMaxPacketLength*2+64;

	if(nMaxPacketLength)
		m_pbyPackedPacket=new BYTE[nMaxPacketLength*2+64];
	else
		m_pbyPackedPacket=NULL;
}

////////////////////////////////////////////////////////////
//pbyFrame-------一帧数据
//nFrameLength---帧长
//Purpose-----------将帧打成包，并送入m_PacketList中。
BOOL CSendChannel::SendData(BYTE* pbyFrame,int nFrameLength)
{
	//Lock();
	CSingleLock sLock(&m_LockSection);
	sLock.Lock();

	static CPacker Packer;

	int nPacketNumber=nFrameLength/m_nMaxPacketLength;
	int nRemainderLength=nFrameLength%m_nMaxPacketLength;
	int nOffset=0;	
	int nPackedPacketLength=0;

	for(int i=0;i<nPacketNumber;i++)
	{
		Packer.Pack(pbyFrame+nOffset,m_nMaxPacketLength,
					m_pbyPackedPacket,m_nMaxPackedPacketLength,
					&nPackedPacketLength,(BYTE)m_nChannelNumber,PT_CONTINUE);

		nOffset+=m_nMaxPacketLength;
		CPacket tempPacket(m_pbyPackedPacket,nPackedPacketLength);
		m_PacketList.AddTail(tempPacket);
	}

	Packer.Pack(pbyFrame+nOffset,nRemainderLength,
					m_pbyPackedPacket,m_nMaxPackedPacketLength,
					&nPackedPacketLength,(BYTE)m_nChannelNumber,PT_END);

	CPacket tempPacket(m_pbyPackedPacket,nPackedPacketLength);
	m_PacketList.AddTail(tempPacket);

	//Unlock();
	return TRUE;
}

int CSendChannel::GetLength()
{
	//Lock();
	CSingleLock sLock(&m_LockSection);
	sLock.Lock();

	int nLength=0;
	int nElementCount=m_PacketList.GetCount();
	POSITION pos=m_PacketList.GetHeadPosition();

	for(int j=0;j<nElementCount;j++)				
		nLength+=m_PacketList.GetNext(pos).m_nLength;

	//Unlock();
	return nLength;

}

int CSendChannel::GetCount(void)
{
//	Lock();
	CSingleLock sLock(&m_LockSection);
	sLock.Lock();
	int nCount=m_PacketList.GetCount();
	//Unlock();
	return nCount;
}

CPacket CSendChannel::GetPacket(int nPos)
{	
	//Lock();
	CSingleLock sLock(&m_LockSection);
	sLock.Lock();

	CPacket Packet;
	if(nPos>=0)
	{
		if(m_PacketList.GetCount()>nPos)
		{
			POSITION Pos=m_PacketList.FindIndex(nPos);
			if(Pos!=NULL)			
				Packet=m_PacketList.GetAt(Pos);
		}
	}
	//Unlock();
	return Packet;
}

CPacket CSendChannel::GetHead(void)
{	
	//Lock();
	CSingleLock sLock(&m_LockSection);
	sLock.Lock();

	CPacket Packet;
	if(!m_PacketList.IsEmpty())
		Packet=m_PacketList.GetHead();
	//Unlock();
	return Packet;
}

CPacket CSendChannel::RemoveHead(void)
{	
	//Lock();
	CSingleLock sLock(&m_LockSection);
	sLock.Lock();

	CPacket Packet;
	if(!m_PacketList.IsEmpty())
		Packet=m_PacketList.RemoveHead();
	//Unlock();
	return Packet;
}

//the begin of class CReceiveChannel
CReceiveChannel::CReceiveChannel(int nChannelNumber,
								 int nPriority,
								 int nMaxFrameLength,
								 PChannelCallBackFunc pChannelCallBackFunc)
								:CChannel(nChannelNumber,nPriority)
{	
	m_nMaxFrameLength=nMaxFrameLength;
	m_lpUserData=NULL;
	m_pChannelCallBackFunc=pChannelCallBackFunc;
	m_pFrameBuffer=NULL;
	m_nValidLength=0;

	if(nMaxFrameLength)
		m_pFrameBuffer=new BYTE[nMaxFrameLength];
}

void CReceiveChannel::Initialize(LPVOID lpUserData)
{
	m_lpUserData=lpUserData;
}

//组装完成后，将根据媒体类型调用相应的回调函数将packet送入相应的
//解码器中（音频解码器，视频解码器，命令解码器）
void CReceiveChannel::InputPacket(BYTE* pbyPacket,int nLength,BOOL bIsEndPacket)
{
	if(m_nValidLength+nLength<=m_nMaxFrameLength)
	{
		CopyMemory(m_pFrameBuffer+m_nValidLength,pbyPacket,nLength);
		m_nValidLength+=nLength;

		if(bIsEndPacket)//组装完成
		{			
			if(m_pChannelCallBackFunc)
				(*m_pChannelCallBackFunc)(m_pFrameBuffer,m_nValidLength,FS_VALID,m_lpUserData);
			m_nValidLength=0;
		}
		return;
	}	
	else
	{	
		 if(m_pChannelCallBackFunc)
		 {
			(*m_pChannelCallBackFunc)(m_pFrameBuffer,m_nValidLength,FS_INVALID,m_lpUserData);
			(*m_pChannelCallBackFunc)(pbyPacket,nLength,FS_INVALID,m_lpUserData);
		 }
		m_nValidLength=0;
	}
}

void CSendChannel::ClearChannelData()
{
	if(!m_PacketList.IsEmpty())
		m_PacketList.RemoveAll();
}