queue.cpp

自己在wince的环境下做的一移动数字电视驱动

#include "stdafx.h"
#include "Queue.h"
//
// CDataQueue Class
//

//
// Constructor
//
CDataQueue::CDataQueue(DWORD dwSize, BOOL *phr)
    : mpBuf(NULL)
    , mSize(0)
    , mHead(-1)
    , mTail(0)
    , mState(0)
    , mIsEos(FALSE)
    , mSum(0)
{
   mpBuf = new BYTE[dwSize];
   memset(mpBuf,0,sizeof(BYTE)*dwSize);
   if (phr) {
      if (mpBuf) {
		  mSize = dwSize;
         *phr = TRUE;
		 InitializeCriticalSection(&mStateLock);		 
      }
      else
         *phr = FALSE;
   }
}

//
// Destructor
//
CDataQueue::~CDataQueue()
{
   Initialize();
   if (mpBuf)
      delete [] mpBuf;
   DeleteCriticalSection(&mStateLock);
}

//
// Initialize
//
void CDataQueue::Initialize()
{ 
	EnterCriticalSection(&mStateLock);
	mHead = -1;
	mTail = 0;
	mSum =0;
	if(mpBuf)
		memset(mpBuf,0,mSize);
	LeaveCriticalSection(&mStateLock);
}

//
//GetSum
//
unsigned int CDataQueue::GetSum()
{
	int sum=0;
	EnterCriticalSection(&mStateLock);
	sum=mSum;
	LeaveCriticalSection(&mStateLock);
	return sum;
}

//
// FreeSize
//
DWORD CDataQueue::FreeSize()
{
	int size=0;
 	EnterCriticalSection(&mStateLock);
	if(mHead==-1)
		size=mSize;
	else if(mTail==-1)
		size=0;
	else
		size=(mTail >= mHead) ? (mSize - (mTail - mHead))
			  : (mHead - mTail);
	LeaveCriticalSection(&mStateLock);
    return size;
}

//
// FillSize
//
DWORD CDataQueue::FillSize()
{   
	int size=0;
 	EnterCriticalSection(&mStateLock);
	if(mHead==-1)
		size=0;
	else if(mTail==-1)
		size=mSize;
	else
		size=(mTail >= mHead) ? (mTail - mHead)
		  : (mSize - (mHead - mTail));
	LeaveCriticalSection(&mStateLock);
    return size;
}

//
// Peek
//
DWORD CDataQueue::Peek(DWORD dwPos, DWORD dwSize)
{
   BYTE bData[4];
   DWORD dwFill, dwData = 0, dwSizeToEnd, i;
   
   if (dwSize > 4)
      return 0;
   
   while ((dwFill = FillSize()) < dwPos+dwSize
      && !mIsEos && mState != 0)
      Sleep(1);
   
   if (dwFill < dwPos+dwSize)
      return 0;
   
//   CAutoLock cAutoLock(&mStateLock);
   
   dwSizeToEnd = mSize - mHead;
   
   if (dwSizeToEnd >= dwPos+dwSize) {
      for (i = 0; i < dwSize; i++)
         dwData |= (DWORD)mpBuf[mHead+dwPos+i] << ((dwSize-(i+1)) << 3);
   }
   else {
      if (dwSizeToEnd > dwPos) {
         CopyMemory(bData, &mpBuf[mHead+dwPos], dwSizeToEnd-dwPos);
         CopyMemory(bData+dwSizeToEnd-dwPos, &mpBuf[0], dwPos+dwSize-dwSizeToEnd);
         for (i = 0; i < dwSize; i++)
            dwData |= (DWORD)bData[i] << ((dwSize-(i+1)) << 3);
      }
      else {
         for (i = 0; i < dwSize; i++)
            dwData |= (DWORD)mpBuf[dwPos-dwSizeToEnd+i] << ((dwSize-(i+1)) << 3);
      }
   }
   
   return dwData;
}

//
// Flush
//
void CDataQueue::Flush(DWORD dwSize)
{
   DWORD dwFill, dwIdx;
   int	 loop_count;

   loop_count=100;
   while ((dwFill = FillSize()) < dwSize)
   {
      Sleep(1);
	  loop_count--;
	  if (loop_count==0)
		break;
   }
   
   
   if (dwFill < dwSize) {
         return;
   }
   
   EnterCriticalSection(&mStateLock);
   if(mTail==-1)
	   mTail=mHead;
   dwIdx = mHead + dwSize;  
   if (dwIdx < mSize)
      mHead = dwIdx;
   else
      mHead = dwIdx - mSize;
   if(mHead==mTail)
	   mHead=-1;   
   mSum -= dwSize;
   LeaveCriticalSection(&mStateLock);
}

//
//Clear
//
void CDataQueue::Clear()
{
	Initialize();
}

//
// Fill
//
void CDataQueue::Fill(DWORD dwSize)
{
   DWORD dwFree, dwIdx;
   
   int	 loop_count;

   loop_count=100;
   while ((dwFree = FreeSize()) < dwSize)
   {
      Sleep(1);
	  loop_count--;
	  if (loop_count==0)
		break;
   }
   
   if (dwFree < dwSize)
      return;
   
   EnterCriticalSection(&mStateLock);
   if(mHead==-1)
	   mHead=mTail;
   dwIdx = mTail + dwSize;  
   if(dwIdx < mSize)
      mTail = dwIdx;
   else
      mTail = dwIdx - mSize;
   if(mTail==mHead)
	   mTail=-1;
   mSum +=dwSize;
   LeaveCriticalSection(&mStateLock);
}

//
// GetInputBufPointer
//
void CDataQueue::GetInputBufPointer(PBYTE *ppbBuf,
                                    PBYTE *ppbBuf2,
                                    DWORD *pdwSize,
                                    DWORD *pdwSize2)
{
   DWORD dwFree, dwSizeToEnd;
   int	 loop_count;

   loop_count=50;
   while ((dwFree = FreeSize()) < *pdwSize)
   {
      Sleep(1);
	  loop_count--;
	  if (loop_count==0)
		break;
   }
  
   if (dwFree < *pdwSize) {
      *ppbBuf = *ppbBuf2 = NULL;
      *pdwSize = *pdwSize2 = 0;
      return;
   }
   
   EnterCriticalSection(&mStateLock);   
   dwSizeToEnd = mSize - mTail;   
   if (dwSizeToEnd >= *pdwSize) {
      *ppbBuf = &mpBuf[mTail];
      *ppbBuf2 = NULL;
      *pdwSize2 = 0;
   }
   else {
      *ppbBuf = &mpBuf[mTail];
      *ppbBuf2 = &mpBuf[0];
      *pdwSize2 = *pdwSize - dwSizeToEnd;
      *pdwSize = dwSizeToEnd;
   }
   LeaveCriticalSection(&mStateLock);
   
   return;
}

//
// GetOutputBufPointer
//
void CDataQueue::GetOutputBufPointer(PBYTE *ppbBuf,
                                     PBYTE *ppbBuf2,
                                     DWORD *pdwSize,
                                     DWORD *pdwSize2)
{
   DWORD dwFill, dwSizeToEnd;
   int	 loop_count;

   loop_count=50;
   while ((dwFill = FillSize()) < (*pdwSize))
   {
      Sleep(1);
	  loop_count--;
	  if (loop_count==0)
		break;
   }
         
   if (dwFill < (*pdwSize)) {
       *ppbBuf = *ppbBuf2 = NULL;
       *pdwSize = *pdwSize2 = 0;
	   return;
   }
   
   EnterCriticalSection(&mStateLock);
   
   dwSizeToEnd = mSize - mHead;
   
   if (dwSizeToEnd >= (*pdwSize)) {
      *ppbBuf = &mpBuf[mHead];
      *ppbBuf2 = NULL;
      *pdwSize2 = 0;
   }
   else {
      *ppbBuf = &mpBuf[mHead];
      *ppbBuf2 = &mpBuf[0];
      *pdwSize2 = *pdwSize - (dwSizeToEnd);
      *pdwSize = dwSizeToEnd;
   }
   LeaveCriticalSection(&mStateLock);
   
   return;
}

//
// Get
//
#if 1
DWORD CDataQueue::Get(BYTE *pbDst, DWORD dwBytesToCopy)
{
   if(pbDst==NULL)
	  return 0;

   if (dwBytesToCopy == 0)
      return 0;

   BYTE *pbSrc = NULL;
   BYTE *pbSrc2 = NULL;
   DWORD dwSrcSize = dwBytesToCopy;
   DWORD dwSrcSize2 = 0;
   
   GetOutputBufPointer(&pbSrc, &pbSrc2, &dwSrcSize, &dwSrcSize2);
   
   if (pbSrc && dwSrcSize)
      memcpy(pbDst, pbSrc, dwSrcSize);
   
   if (pbSrc2 && dwSrcSize2)
      memcpy(pbDst+dwSrcSize, pbSrc2, dwSrcSize2);

   if(dwSrcSize>0)
	   Flush(dwSrcSize + dwSrcSize2);
   
   return dwSrcSize + dwSrcSize2;
}
#else
DWORD CDataQueue::Get(BYTE *pbDst, DWORD dwBytesToCopy)
{
   if(pbDst==NULL)
	  return 0;

   if (dwBytesToCopy == 0)
      return 0;

    int size=0;
	DWORD dwFill, dwSizeToEnd;

   int	 loop_count;
   loop_count=100;
   while ((size = FillSize()) < dwBytesToCopy)
   {
      Sleep(1);
	  loop_count--;
	  if (loop_count==0)
		break;
   }    
/*	
	EnterCriticalSection(&mStateLock);
	if(mHead==-1)
		size=0;
	else if(mTail==-1)
		size=mSize;
	else
		size=(mTail >= mHead) ? (mTail - mHead)
		  : (mSize - (mHead - mTail));
//*/

	if(size<dwBytesToCopy)
	{
//		LeaveCriticalSection(&mStateLock);
		return 0;
	}else
		EnterCriticalSection(&mStateLock);

   dwSizeToEnd = mSize - mHead;
   if(mTail==-1)
	   mTail=mHead;
   if (dwSizeToEnd >= dwBytesToCopy) {
		memcpy(pbDst,&mpBuf[mHead],dwBytesToCopy);
		mHead +=dwBytesToCopy;
   }
   else {
		memcpy(pbDst,&mpBuf[mHead],dwSizeToEnd);
		memcpy(pbDst+dwSizeToEnd,&mpBuf[0],dwBytesToCopy-dwSizeToEnd);
		mHead = dwBytesToCopy-dwSizeToEnd;
   }	
   if(mHead==mTail)
	   mHead=-1;
   mSum-=dwBytesToCopy;
   LeaveCriticalSection(&mStateLock);
   return dwBytesToCopy;
}
#endif

//
// Put
//
#if 1
DWORD CDataQueue::Put(BYTE *pbSrc, DWORD dwBytesToCopy)
{
   if(pbSrc==NULL)
	  return 0;
   
   if (dwBytesToCopy == 0)
      return 0;
   
   BYTE *pbDst = 0;
   BYTE *pbDst2 = 0;
   DWORD dwDstSize = dwBytesToCopy;
   DWORD dwDstSize2 = 0;
      
   GetInputBufPointer(&pbDst, &pbDst2, &dwDstSize, &dwDstSize2);
   
   if (pbDst && dwDstSize)
      memcpy(pbDst, pbSrc, dwDstSize);
   
   if (pbDst2 && dwDstSize2)
      memcpy(pbDst2, pbSrc+dwDstSize, dwDstSize2);
   
   if(dwDstSize>0)
	   Fill(dwDstSize + dwDstSize2);
   
   return dwDstSize + dwDstSize2;
}
#else
DWORD CDataQueue::Put(BYTE *pbSrc, DWORD dwBytesToCopy)
{
   if(pbSrc==NULL)
	  return 0;
   
   if (dwBytesToCopy == 0)
      return 0;
   
	int size=0;
    DWORD dwFree, dwSizeToEnd;

   int loop_count=100;
   while ((size = FreeSize()) < dwBytesToCopy)
   {
      Sleep(1);
	  loop_count--;
	  if (loop_count==0)
		break;
   }	
/*
 	EnterCriticalSection(&mStateLock);
	if(mHead==-1)
		size=mSize;
	else if(mTail==-1)
		size=0;
	else
		size=(mTail >= mHead) ? (mSize - (mTail - mHead))
			  : (mHead - mTail);
//*/	
	if(size<dwBytesToCopy)
	{
//		LeaveCriticalSection(&mStateLock);
		return 0;
	}else
		EnterCriticalSection(&mStateLock);

   dwSizeToEnd = mSize - mTail; 
   if(mHead==-1)
	   mHead=mTail;
   if (dwSizeToEnd >= dwBytesToCopy) {
		memcpy(&mpBuf[mTail],pbSrc,dwBytesToCopy);
		mTail +=dwBytesToCopy;
   }else{
		memcpy(&mpBuf[mTail],pbSrc,dwSizeToEnd);
		memcpy(&mpBuf[0],pbSrc+dwSizeToEnd,dwBytesToCopy-dwSizeToEnd);
		mTail = dwBytesToCopy-dwSizeToEnd;
   }
   if(mTail==mHead)
	   mTail=-1;
    mSum+=dwBytesToCopy;
  LeaveCriticalSection(&mStateLock);
   return dwBytesToCopy;
}
#endif

DWORD CDataQueue::PeekLocked(DWORD dwPos, DWORD dwSize)
{
	DWORD dwData = 0;
	DWORD i;
	for (i = 0; i < dwSize; i++)
		dwData |= (DWORD)mpBuf[mHead+dwPos+i] << ((dwSize-(i+1)) << 3);
   
   return dwData;
}

DWORD CDataQueue::GetLocked(BYTE *pbDst, DWORD dwPos, DWORD dwBytesToCopy)
{
	if (dwBytesToCopy == 0)
		return 0;
   
	memcpy(pbDst, &mpBuf[mHead+dwPos], dwBytesToCopy);
   
	return dwBytesToCopy;
}