bufferqueue.cpp

缓冲 缓冲 缓冲 缓冲 缓冲 缓冲

// BufferQueue.cpp: implementation of the BufferQueue class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MultiBuffer.h"
#include "BufferQueue.h"

#include <assert.h>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


BufferQueue::BufferQueue():readPos(0),num(0),validFlag(true)
{
#ifdef WIN32
	hFullEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
	assert(hFullEvent);
	hEmptyEvent = CreateEvent(NULL,FALSE,TRUE,NULL);
	assert(hEmptyEvent);
#endif
}

BufferQueue::~BufferQueue()
{
}

int BufferQueue::lockAccessMutex()
{
#ifdef WIN32
	return accessMutex.Lock();
#else
	return pthread_mutex_lock(&accessMutex);
#endif
}

int BufferQueue::unLockAccessMutex()
{
#ifdef WIN32
	return accessMutex.Unlock();
#else
	return pthread_mutex_unlock(&accessMutex);
#endif
}

Buffer* BufferQueue::getReadBuffer()
{
	Buffer *readBuffer = NULL;
	lockAccessMutex();
	while(num==0&&validFlag)
	{
		unLockAccessMutex();
		//wait for writer to produce data
		while(WaitForSingleObject(hEmptyEvent,INFINITE)!=WAIT_OBJECT_0);
		printf("Wait for Read Buffer Over\n");
		lockAccessMutex();
	}
	if(num>0)
	{
		readBuffer = &buffers[readPos];
		printf("Get Read Buffer:%x\n",readBuffer);
	}
	unLockAccessMutex();

	return readBuffer;

}

Buffer* BufferQueue::getWriteBuffer()
{
	Buffer *writeBuffer = NULL;
	lockAccessMutex();
	while(num==numOfBuffers()&&validFlag)
	{
		unLockAccessMutex();
		//wait for writer to produce data
		while(WaitForSingleObject(hFullEvent,INFINITE)!=WAIT_OBJECT_0);
		printf("Wait for write buffer over\n");
		lockAccessMutex();
	}
	if(validFlag&&num>=0)
	{
		writeBuffer = &buffers[(readPos+num)%numOfBuffers()];
		printf("Get Write Buffer:%x\n",writeBuffer);
	}
	unLockAccessMutex();
	
	return writeBuffer;
}

/*
 * This is used by read thread 
*/
bool BufferQueue::moveReadBuffer(bool needToMove)
{
	lockAccessMutex();
	int tempNum = num;
	if(needToMove)
	{
		readPos = (readPos+1)%numOfBuffers();
		num--;
	}
	unLockAccessMutex();
	if(tempNum==numOfBuffers())
		SetEvent(hFullEvent); //signal writer to place data in buffer
	return true;
}

bool BufferQueue::moveWriteBuffer(bool needToMove)
{
	lockAccessMutex();
	int tempNum = num;
	if(needToMove)
		num++;
	unLockAccessMutex();
	if(tempNum==0)
		SetEvent(hEmptyEvent); //signal reader to retrieve data
	return true;
}

void BufferQueue::invalidate()
{
	lockAccessMutex();
	validFlag = false;
	unLockAccessMutex();
}