myvtm/Framework/RvcLogSdk/libsharequeue.cpp

#include "libsharequeue.h"
#include "libsharememory.h"
#include "inner_log.h"

#if defined(_MSC_VER)
#include <windows.h>
#else
#define  ENABLE_LOG_4_SHAREQUEUE
#endif //_MSC_VER

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 libsharequeue_impl
{
private:
	Clibsharememory4SDK m_ShareMem;
	void* m_lpMem;
	linkqueue*m_pQueue;
	int m_nTimeSignLens;
	int m_nQueueAddrLens;
	int m_nQnodeAddrLens;
	int m_nFrameAddrLens;
	int m_nDataAddrlens;
	char* szShareMemName;
	unsigned long aQnodeAddr[MAX_SHAREQUEUE_LENS];
	unsigned long aShareFrameAddr[MAX_SHAREQUEUE_LENS];
	unsigned long aImgDataAddr[MAX_SHAREQUEUE_LENS];
	unsigned long nTimeSignAddr;
public:
	libsharequeue_impl(char* queuename, bool newcreate, int size= MAX_SHAREQNODE_SIZE)
	{
		m_lpMem = NULL;
		m_pQueue = NULL;
		szShareMemName = NULL;
		m_nQueueAddrLens = 0;
		m_nQnodeAddrLens = 0;
		m_nTimeSignLens = 0;
		m_nFrameAddrLens = 0;
		m_nDataAddrlens = 0;
		for(int i=0;i< MAX_SHAREQUEUE_LENS;i++)
		{
			aQnodeAddr[i] = 0;
			aShareFrameAddr[i] = 0;
			aImgDataAddr[i] = 0;
		}
		nTimeSignAddr = 0;
		InitQueue(queuename, newcreate, size);
	}

	~libsharequeue_impl()
	{
		ClearQueue();
	}
	//初始化队列
	bool InitQueue(const char* szName, bool createFlag, int size)
	{
		aos_debug_log((LB, "enter init queue %s, %s", szName, createFlag ? "true" : "false"));
		m_nQueueAddrLens = sizeof(linkqueue);
		m_nQnodeAddrLens = MAX_SHAREQUEUE_LENS *sizeof(Qnode);
		m_nFrameAddrLens = MAX_SHAREQUEUE_LENS *sizeof(shareq_frame);
		m_nDataAddrlens	= MAX_SHAREQUEUE_LENS * size;
		m_nTimeSignLens = sizeof(unsigned int);
		unsigned long nMemTotalNum = m_nTimeSignLens+m_nQueueAddrLens+m_nQnodeAddrLens+m_nFrameAddrLens+m_nDataAddrlens;
#if defined(_MSC_VER)
		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_SHAREQUEUE_LENS; i++) {
					aQnodeAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + sizeof(Qnode) * i;
					aShareFrameAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + sizeof(shareq_frame) * i;
					aImgDataAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + size * i;
				}
				nTimeSignAddr = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + m_nDataAddrlens;
				m_pQueue->frontindex = m_pQueue->rearindex = 0;
				m_pQueue->queuelens = 0;
				m_ShareMem.Unlock();
			}

	} else if (m_ShareMem.Open(szName, nMemTotalNum)) {
		int i = m_ShareMem.GetBytes();
		m_lpMem = m_ShareMem.Lock(1000);
		if (m_lpMem != NULL) {
			m_pQueue = (linkqueue*)m_lpMem;
			for (int i = 0; i < MAX_SHAREQUEUE_LENS; i++) {
				aQnodeAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + sizeof(Qnode) * i;
				aShareFrameAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + sizeof(shareq_frame) * i;
				aImgDataAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + size * i;
			}
			nTimeSignAddr = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + m_nDataAddrlens;
			m_ShareMem.Unlock();
		}
	}
	return true;
#else
		if (createFlag && m_ShareMem.Create(szName, nMemTotalNum)) {
			aos_debug_log((LB, "create share mem succ."));
			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_SHAREQUEUE_LENS; i++) {
					aQnodeAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + sizeof(Qnode) * i;
					aShareFrameAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + sizeof(shareq_frame) * i;
					aImgDataAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + size * i;
				}
				nTimeSignAddr = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + m_nDataAddrlens;
				m_pQueue->frontindex = m_pQueue->rearindex = 0;
				m_pQueue->queuelens = 0;
				m_ShareMem.Unlock();
			}
			return true;
		} else if (!createFlag && m_ShareMem.Open(szName, nMemTotalNum)) {
			aos_debug_log((LB, "open share mem succ."));
			int i = m_ShareMem.GetBytes();
			m_lpMem = m_ShareMem.Lock(1000);
			if (m_lpMem != NULL) {
				m_pQueue = (linkqueue*)m_lpMem;
				for (int i = 0; i < MAX_SHAREQUEUE_LENS; i++) {
					aQnodeAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + sizeof(Qnode) * i;
					aShareFrameAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + sizeof(shareq_frame) * i;
					aImgDataAddr[i] = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + size * i;
				}
				nTimeSignAddr = (unsigned long)m_pQueue + m_nQueueAddrLens + m_nQnodeAddrLens + m_nFrameAddrLens + m_nDataAddrlens;
				aos_debug_log((LB, "frontindex: %d, rearindex: %d, len: %u", m_pQueue->frontindex, m_pQueue->rearindex, m_pQueue->queuelens));
				m_ShareMem.Unlock();
			}
			return true;
		} else {
			aos_error_log((LB, "create or open share mem failed!"));
		}
		return false;
#endif //_MSC_VER
	}
	//返回队列的元素个数，视频队列长度
	int GetLens()
	{
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				int num = m_pQueue->queuelens;
				m_ShareMem.Unlock();
				return num;
			}
			else
			{
				m_ShareMem.Unlock();
				return 0;
			}
		}
		else
		{
			return 0;
		}
	}
	//往视频循环队列尾部插节点
	bool Insert(shareq_frame* frame,unsigned int nowtime)
	{
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL && m_pQueue != NULL)
			{
				unsigned int nRearNextIndex = 0;
				//保存当前对位指针的序列号
				queueptr rearptrfront = (queueptr)aQnodeAddr[m_pQueue->rearindex];
#ifdef ENABLE_LOG_4_SHAREQUEUE
                do {
                    char* szLogBuf = AllocLogBuf();
                    char szLevel[10];
					char szTime[32];
                    szLogBuf[2047] = 0;
                    MakeLogPrefix(LM_DEBUG, szLevel, szTime);
                    _snprintf(szLogBuf, 2047, "Insert, frontindex %d, rearindex %d.", m_pQueue->frontindex, m_pQueue->rearindex);
                    RvcLog_log(__FILE__, __LINE__, 1, LM_DEBUG, szLevel, szTime, szLogBuf);
                } while (0);
#endif

				//如果队列已满
				if ((m_pQueue->rearindex+1)% MAX_SHAREQUEUE_LENS == m_pQueue->frontindex)
				{
					return false;
				}
				m_pQueue->queuelens++;
				if (frame != NULL)
				{
					queueptr rearqnodetmp			= (queueptr)aQnodeAddr[m_pQueue->rearindex];
					rearqnodetmp->videoframeindex	= m_pQueue->rearindex;
					rearqnodetmp->nextqnodeindex	= 0;
					shareq_frame*sharetmp			= (shareq_frame*)aShareFrameAddr[m_pQueue->rearindex];
					sharetmp->data					= (unsigned char*)aImgDataAddr[m_pQueue->rearindex ];
					sharetmp->size					= frame->size;
					unsigned int*Ptr				= (unsigned int*)nTimeSignAddr;
					*Ptr	= nowtime;
					memcpy(sharetmp->data, frame->data, frame->size);

					rearptrfront->nextqnodeindex = m_pQueue->rearindex;
					m_pQueue->rearindex = (m_pQueue->rearindex + 1) % MAX_SHAREQUEUE_LENS;
#ifdef ENABLE_LOG_4_SHAREQUEUE
					do
					{
						char* szLogBuf = AllocLogBuf();
						char szLevel[10];
						char szTime[32];
						szLogBuf[2047] = 0;
						MakeLogPrefix(LM_DEBUG, szLevel, szTime);
						_snprintf(szLogBuf, 2047, "Insert2, frontindex %d, rearindex %d.", m_pQueue->frontindex, m_pQueue->rearindex);
						RvcLog_log(__FILE__, __LINE__, 1, LM_DEBUG, szLevel, szTime, szLogBuf);
					} while (0);
#endif
				}
				m_ShareMem.Unlock();
				return true;
			}
			else
			{
				m_ShareMem.Unlock();
				return false;
			}

		}
		else
		{
			return false;
		}
	}
	//读视频队列头部节点
	bool Get(shareq_frame* frame)
	{
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				if (m_pQueue->queuelens == 0)
				{
					m_ShareMem.Unlock();
					return false;
				}
				else
				{
					shareq_frame* sharetemp = (shareq_frame*)aShareFrameAddr[m_pQueue->frontindex];
					frame->size = sharetemp->size;
					memcpy(frame->data, sharetemp->data, sharetemp->size);
					m_ShareMem.Unlock();
					return true;
				}
			}
			else
			{
				m_ShareMem.Unlock();
				return false;
			}
		}
		else
		{
			return false;
		}		
	}

	//读视频队列头部节点,并删除头部节点
	bool GetAndDel(shareq_frame* frame)
	{
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
#ifdef ENABLE_LOG_4_SHAREQUEUE
				do
				{
					char* szLogBuf = AllocLogBuf();
					char szLevel[10];
					char szTime[32];
					szLogBuf[2047] = 0;
					MakeLogPrefix(LM_DEBUG, szLevel, szTime);
					_snprintf(szLogBuf, 2047, "GetAndDel, frontindex %d, rearindex %d.", m_pQueue->frontindex, m_pQueue->rearindex);
					RvcLog_log(__FILE__, __LINE__, 1, LM_DEBUG, szLevel, szTime, szLogBuf);
				}while (0);
#endif
				//if (m_pQueue->queuelens == 0)
				if (m_pQueue->frontindex == m_pQueue->rearindex)
				{
					m_ShareMem.Unlock();
					return false;
				}
				else
				{
					shareq_frame* sharetemp = (shareq_frame*)aShareFrameAddr[m_pQueue->frontindex];
					frame->size = sharetemp->size;
					memcpy(frame->data, (unsigned char*)aImgDataAddr[m_pQueue->frontindex], sharetemp->size);

					unsigned char*data = (unsigned char*)aImgDataAddr[m_pQueue->frontindex];
					memset(data,0, sharetemp->size);
					memset(sharetemp,0,sizeof(shareq_frame));
					queueptr qnodetmp			= (queueptr)aQnodeAddr[m_pQueue->frontindex];
					//m_pQueue->frontindex		= qnodetmp->nextqnodeindex;
					m_pQueue->frontindex = (m_pQueue->frontindex + 1) % MAX_SHAREQUEUE_LENS;
					qnodetmp					= (queueptr)aQnodeAddr[m_pQueue->rearindex];
					qnodetmp->nextqnodeindex	= 0;
					m_pQueue->queuelens--;
#ifdef ENABLE_LOG_4_SHAREQUEUE
					do
					{
						char* szLogBuf = AllocLogBuf();
						char szLevel[10];
						char szTime[32];
						szLogBuf[2047] = 0;
						MakeLogPrefix(LM_DEBUG, szLevel, szTime);
						_snprintf(szLogBuf, 2047, "GetAndDel2, frontindex %d, rearindex %d.", m_pQueue->frontindex, m_pQueue->rearindex);
						RvcLog_log(__FILE__, __LINE__, 1, LM_DEBUG, szLevel, szTime, szLogBuf);
					} while (0);
#endif
					m_ShareMem.Unlock();
					return true;
				}
			}
			else
			{
				m_ShareMem.Unlock();
				return false;
			}
		}
		else
		{
			return false;
		}		
	}
	//清除队列
	int ClearQueue()
	{
		shareq_frame frame;
		unsigned char buffer[MAX_SHAREQNODE_SIZE];
		frame.data = buffer;
		while (!IsEmpty()) {
			GetAndDel(&frame);
		}
		return 0;
		/*
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				if (m_pQueue->queuelens != 0)
				{
					while(m_pQueue->queuelens != 0)
					{
						shareq_frame* sharetemp = (shareq_frame*)aShareFrameAddr[m_pQueue->frontindex];
						unsigned char*data = (unsigned char*)aImgDataAddr[m_pQueue->frontindex];
						memset(data,0, sharetemp->size);
						memset(sharetemp,0,sizeof(shareq_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();
				return TRUE;
			}
			else
			{
				return FALSE;
			}
		}
		else
		{
			return FALSE;
		}	
		*/
	}

	//删除队头的数据
	int DeleteHead()  
	{
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				if (m_pQueue->queuelens != 0)
				{	
					shareq_frame* sharetemp = (shareq_frame*)aShareFrameAddr[m_pQueue->frontindex];
					unsigned char*data = (unsigned char*)aImgDataAddr[m_pQueue->frontindex];
					memset(data,0, sharetemp->size);
					memset(sharetemp,0,sizeof(shareq_frame));
					queueptr qnodetmp = (queueptr)aQnodeAddr[m_pQueue->frontindex];
					//m_pQueue->frontindex		= qnodetmp->nextqnodeindex;
					m_pQueue->frontindex = (m_pQueue->frontindex + 1) % MAX_SHAREQUEUE_LENS;
					qnodetmp					= (queueptr)aQnodeAddr[m_pQueue->rearindex];
					qnodetmp->nextqnodeindex	= 0;
					m_pQueue->queuelens--;			
				}
				m_ShareMem.Unlock();
				return 1;
			}
			else
			{
				m_ShareMem.Unlock();
				return 0;
			}
		}
		else
		{
			return 0;
		}	
	}
	//获取图像的大小
	int GetFrameSize()
	{
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				int nFrameSize = 0;
				if (m_pQueue->queuelens != 0)
				{	
					shareq_frame* sharetemp = (shareq_frame*)aShareFrameAddr[m_pQueue->frontindex];
					nFrameSize				= sharetemp->size;
				}
				m_ShareMem.Unlock();
				return nFrameSize;
			}
			else
			{
				m_ShareMem.Unlock();
				return 0;
			}
		}
		else
		{
			return 0;
		}
	}

	unsigned int GetLastFrameTime()
	{
		if(m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if(m_lpMem != NULL)
			{
				unsigned int nLastFrameTime = 0;
				nLastFrameTime = *(unsigned int *)nTimeSignAddr;
				m_ShareMem.Unlock();
				return nLastFrameTime;
			}
			else
			{
				m_ShareMem.Unlock();
				return 0;
			}
		}
		else
		{
			return 0;
		}
	}

	bool IsEmpty() {
		if (m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if (m_lpMem != NULL)
			{
				const int result = !!(m_pQueue->frontindex == m_pQueue->rearindex);
				m_ShareMem.Unlock();
				return result;
			}
			else
			{
				m_ShareMem.Unlock();
				return true;
			}
		}
		else
		{
			return true;
		}

	}

	bool IsFull() {
		if (m_ShareMem.IsValid())
		{
			m_lpMem = m_ShareMem.Lock(1000);
			if (m_lpMem != NULL)
			{
				const bool result = (m_pQueue->rearindex + 1) % MAX_SHAREQUEUE_LENS == m_pQueue->frontindex;
				m_ShareMem.Unlock();
				return result;
			}
			else
			{
				m_ShareMem.Unlock();
				return true;
			}
		}
		else
		{
			return true;
		}

	}

};


struct Clibsharequeue_t {
	libsharequeue_impl* m_pImpl;
};


Clibsharequeue* ClibsharequeueCreate(char* queuename, int size) {
	Clibsharequeue* queue = (Clibsharequeue*)malloc(sizeof(struct Clibsharequeue_t));
	queue->m_pImpl = new libsharequeue_impl(queuename, false, size);
	return queue;
}

Clibsharequeue* ClibsharequeueCreate2(char* queuename) {
	Clibsharequeue* queue = (Clibsharequeue*)malloc(sizeof(struct Clibsharequeue_t));
	queue->m_pImpl = new libsharequeue_impl(queuename, false, MAX_SHAREQNODE_SIZE);
	return queue;
}

Clibsharequeue* ClibsharequeueCreate3(char* queuename, int newcreate)
{
    Clibsharequeue* queue = (Clibsharequeue*)malloc(sizeof(struct Clibsharequeue_t));
    queue->m_pImpl = new libsharequeue_impl(queuename, !!newcreate, MAX_SHAREQNODE_SIZE);
    return queue;
}

void ClibsharequeueDestroy(Clibsharequeue* queue) {
	if (queue != NULL) {
		ClibsharequeueClearQueue(queue);
		if (queue->m_pImpl != NULL) {
			delete queue->m_pImpl;
		}
		free(queue);
		queue = NULL;
	}	
	return;
}

int ClibsharequeueInsert(Clibsharequeue* queue, shareq_frame* data, unsigned int nowtime)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		const int bRst = queue->m_pImpl->Insert(data, nowtime) ? 1 : 0;
		return bRst;
	}
	return 0;
}

int ClibsharequeueGet(Clibsharequeue* queue, shareq_frame* data)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		const int bRst = queue->m_pImpl->Get(data) ? 1 : 0;
		return bRst;
	}
	return 0;
}

int ClibsharequeueGetAndDel(Clibsharequeue* queue, shareq_frame* data)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		const int bRst = queue->m_pImpl->GetAndDel(data) ? 1 : 0;
		return bRst;
	}
	return 0;
}

int ClibsharequeueGetLens(Clibsharequeue* queue)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		int i = queue->m_pImpl->GetLens();
		return i;
	}
	return 0;
}

void ClibsharequeueClearQueue(Clibsharequeue* queue)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		queue->m_pImpl->ClearQueue();
		return;
	}
}

int ClibsharequeueGetFrameSize(Clibsharequeue* queue)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		int i = queue->m_pImpl->GetFrameSize();
		return i;
	}
	return 0;
}	

void ClibsharequeueDeleteHead(Clibsharequeue* queue)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		queue->m_pImpl->DeleteHead();
		return;
	}
}

unsigned int ClibsharequeueGetLastFrameTime(Clibsharequeue* queue)
{
	if (queue != NULL && queue->m_pImpl != NULL) {
		return queue->m_pImpl->GetLastFrameTime();
	}
	return 0;
}