myvtm/Other/libaudiotransqueue/libaudiotransqueue.cpp

// libaudiotransqueue.cpp : Defines the exported functions for the DLL application.
//

//#include "stdafx.h"
#include "SpBase.h"
#include "libaudiotransqueue.h"
#include "libsharememory.h"



typedef struct  Qnode
{
	unsigned int videoframeindex;
	unsigned int nextqnodeindex;
}Qnode, *queueptr;

typedef struct linkqueue
{
	unsigned int frontindex;
	unsigned int rearindex;
	unsigned int queuelens;
}linkqueue;

class libaudiotransqueue_impl
{
private:
	Clibsharememory m_ShareMem;
	LPVOID m_lpMem;
	linkqueue*m_pQueue;
	int m_nQueueAddrLens;
	int m_nQnodeAddrLens;
	int m_nFrameAddrLens;
	int m_nDataAddrlens;
	LPCTSTR szShareMemName;
	unsigned long aQnodeAddr[MAX_AUDIOTRANSQUEUE_LENS];
	unsigned long aAudioFrameAddr[MAX_AUDIOTRANSQUEUE_LENS];
	unsigned long aAudioDataAddr[MAX_AUDIOTRANSQUEUE_LENS];

public:
	libaudiotransqueue_impl(LPCTSTR audioqueuename,int framesize=MAX_AUDIOQNODE_SIZE)
	{
		m_lpMem = NULL;
		m_pQueue = NULL;
		szShareMemName = NULL;
		m_nQueueAddrLens = 0;
		m_nQnodeAddrLens = 0;
		m_nFrameAddrLens = 0;
		m_nDataAddrlens = 0;
		for(int i=0;i<MAX_AUDIOTRANSQUEUE_LENS;i++)
		{
			aQnodeAddr[i] = 0;
			aAudioFrameAddr[i] = 0;
			aAudioDataAddr[i] = 0;
		}
		InitQueue(audioqueuename,framesize);
	}

	~libaudiotransqueue_impl()
	{
		ClearQueue();
	}
	//初始化队列
	BOOL InitQueue(LPCTSTR szName,int framesize=MAX_AUDIOQNODE_SIZE)
	{
		m_nQueueAddrLens = sizeof(linkqueue);
		m_nQnodeAddrLens = MAX_AUDIOTRANSQUEUE_LENS*sizeof(Qnode);
		m_nFrameAddrLens = MAX_AUDIOTRANSQUEUE_LENS*sizeof(audio_frame);
		m_nDataAddrlens	= MAX_AUDIOTRANSQUEUE_LENS*framesize;
		int nMemTotalNum = m_nQueueAddrLens+m_nQnodeAddrLens+m_nFrameAddrLens+m_nDataAddrlens;
		if (m_ShareMem.Create(szName,nMemTotalNum)&&(m_nDataAddrlens!=0))
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				memset(m_lpMem,0,nMemTotalNum);
				m_pQueue = (linkqueue *)m_lpMem;
				for(int i =0;i<MAX_AUDIOTRANSQUEUE_LENS;i++)
				{
					aQnodeAddr[i] = (unsigned long)m_pQueue+m_nQueueAddrLens+sizeof(Qnode)*i;
					aAudioFrameAddr[i] = (unsigned long)m_pQueue+m_nQueueAddrLens+m_nQnodeAddrLens+sizeof(audio_frame)*i;
					aAudioDataAddr[i] = (unsigned long)m_pQueue+m_nQueueAddrLens+m_nQnodeAddrLens+m_nFrameAddrLens+framesize*i;
				}
				m_pQueue->frontindex = m_pQueue->rearindex = 0;
				m_pQueue->queuelens = 0;
				m_ShareMem.Unlock();
			}

		} 
		else if(m_ShareMem.Open(szName))
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				m_pQueue = (linkqueue *)m_lpMem;
				for(int i =0;i<MAX_AUDIOTRANSQUEUE_LENS;i++)
				{
					aQnodeAddr[i] = (unsigned long)m_pQueue+m_nQueueAddrLens+sizeof(Qnode)*i;
					aAudioFrameAddr[i] = (unsigned long)m_pQueue+m_nQueueAddrLens+m_nQnodeAddrLens+sizeof(audio_frame)*i;
					aAudioDataAddr[i] = (unsigned long)m_pQueue+m_nQueueAddrLens+m_nQnodeAddrLens+m_nFrameAddrLens+framesize*i;
				}
				m_ShareMem.Unlock();
			}
		}
		return TRUE;
	}
	//返回队列的元素个数，音频队列长度
	int GetQueueLens()
	{
		int iRet = 0;
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				int num = m_pQueue->queuelens;
				m_ShareMem.Unlock();
				iRet = num;
			}
		}

		return iRet;
	}


	//往音频循环队列尾部插节点
	bool EnAudioQueue(audio_frame* pItem)
	{
		bool bRet = false;
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				unsigned int nRearNextIndex = 0;
				//保存当前对位指针的序列号
				queueptr rearptrfront = (queueptr)aQnodeAddr[m_pQueue->rearindex];
				//如果队列已满
				if(m_pQueue->queuelens == MAX_AUDIOTRANSQUEUE_LENS)
				{
					m_pQueue->rearindex = (m_pQueue->rearindex+1)%MAX_AUDIOTRANSQUEUE_LENS;
					m_pQueue->frontindex = (m_pQueue->frontindex+1)%MAX_AUDIOTRANSQUEUE_LENS;
					m_pQueue->queuelens = MAX_AUDIOTRANSQUEUE_LENS;
				}
				else if (m_pQueue->queuelens == 0)
				{
					m_pQueue->rearindex  = 0;
					m_pQueue->frontindex  = 0;
					m_pQueue->queuelens++;
				}
				else
				{
					m_pQueue->rearindex = (m_pQueue->rearindex+1)%MAX_AUDIOTRANSQUEUE_LENS;
					m_pQueue->frontindex = m_pQueue->frontindex;
					m_pQueue->queuelens++;
				}
				if (NULL != pItem)
				{
					queueptr rearqnodetmp			= (queueptr)aQnodeAddr[m_pQueue->rearindex];
					rearqnodetmp->videoframeindex	= m_pQueue->rearindex;
					rearqnodetmp->nextqnodeindex	= 0;
					audio_frame*audiotmp			= (audio_frame*)aAudioFrameAddr[m_pQueue->rearindex];
					audiotmp->data					= (char*)aAudioDataAddr[m_pQueue->rearindex ];
					audiotmp->bitspersample			= pItem->bitspersample;
					audiotmp->format				= pItem->format;
					audiotmp->framesize				= pItem->framesize;
					audiotmp->nchannels				= pItem->nchannels;
					audiotmp->samplespersec			= pItem->samplespersec;
					audiotmp->iseriesnumber			= pItem->iseriesnumber;
					memcpy(audiotmp->data,pItem->data,pItem->framesize);
					rearptrfront->nextqnodeindex = m_pQueue->rearindex;
				}
				m_ShareMem.Unlock();
				bRet = true;
			}
		}
		return bRet;
	}


	//读音频队列头部节点
	bool TryDequeue(audio_frame* pItem)	
	{
		bool bRet = false;
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				if (m_pQueue->queuelens == 0)
				{
					m_ShareMem.Unlock();
					bRet = false;
				}
				else
				{
					audio_frame*audiotemp = (audio_frame*)aAudioFrameAddr[m_pQueue->frontindex];;
					pItem->format			= audiotemp->format;
					pItem->framesize		= audiotemp->framesize;
					pItem->bitspersample	= audiotemp->bitspersample;
					pItem->nchannels		= audiotemp->nchannels;
					pItem->samplespersec	= audiotemp->samplespersec;
					pItem->iseriesnumber	= audiotemp->iseriesnumber;
					memcpy(pItem->data,(char*)aAudioDataAddr[m_pQueue->frontindex],audiotemp->framesize);
					m_ShareMem.Unlock();
					bRet = true;
				}
			}
		}
		return bRet;
	}

	//清除队列
	bool ClearQueue()
	{
		bool bRet = false;
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				if (m_pQueue->queuelens != 0)
				{
					while(m_pQueue->queuelens != 0)
					{
						audio_frame*audiotemp = (audio_frame*)aAudioFrameAddr[m_pQueue->frontindex];
						char*data = (char*)aAudioDataAddr[m_pQueue->frontindex];
						memset(data,0,audiotemp->framesize);
						memset(audiotemp,0,sizeof(audio_frame));
						queueptr qnodetmp			= (queueptr)aQnodeAddr[m_pQueue->frontindex];
						m_pQueue->frontindex		= qnodetmp->nextqnodeindex;
						qnodetmp					= (queueptr)aQnodeAddr[m_pQueue->rearindex];
						qnodetmp->nextqnodeindex	= 0;
						m_pQueue->queuelens--;	
					}					
				}
				m_ShareMem.Unlock();
				bRet = true;
			}
		}
		return bRet;
	}


	//删除队头的数据
	bool DeleteQueueHead()  
	{
		bool bRet = false;
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				if (m_pQueue->queuelens != 0)
				{	
					audio_frame*audiotemp = (audio_frame*)aAudioFrameAddr[m_pQueue->frontindex];
					char*data = (char*)aAudioDataAddr[m_pQueue->frontindex];
					memset(data,0,audiotemp->framesize);
					memset(audiotemp,0,sizeof(audio_frame));
					queueptr qnodetmp			= (queueptr)aQnodeAddr[m_pQueue->frontindex];
					m_pQueue->frontindex		= qnodetmp->nextqnodeindex;
					qnodetmp					= (queueptr)aQnodeAddr[m_pQueue->rearindex];
					qnodetmp->nextqnodeindex	= 0;
					m_pQueue->queuelens--;			
				}
				m_ShareMem.Unlock();
				bRet = true;
			}
		}	
		return bRet;
	}
};


Clibaudiotransqueue::Clibaudiotransqueue(LPCTSTR audioqueuename,int framesize)
{
	m_pImpl = new libaudiotransqueue_impl(audioqueuename,framesize);
	return;
}

Clibaudiotransqueue::~Clibaudiotransqueue()
{
	ClearQueue();
	delete m_pImpl;
	return;
}

bool Clibaudiotransqueue::Enqueue(audio_frame* pItem)
{
	bool bRet = m_pImpl->EnAudioQueue(pItem);
	return bRet;
}

bool Clibaudiotransqueue::TryDequeue(audio_frame* pItem)
{
	bool bRet = m_pImpl->TryDequeue(pItem);
	return bRet;
}

bool Clibaudiotransqueue::DeleteQueueHead()
{
	bool bRet = m_pImpl->DeleteQueueHead();
	return bRet;
}

bool Clibaudiotransqueue::IsEmpty()
{
	bool bRet = m_pImpl->GetQueueLens() == 0 ? true : false;
	return bRet;
}

int Clibaudiotransqueue::Count()
{
	int iRet = m_pImpl->GetQueueLens();
	return iRet;
}

bool Clibaudiotransqueue::ClearQueue()
{
	bool bRet = m_pImpl->ClearQueue();
	return bRet;
}