ringbuffer.cpp

包括语音识别和数字TTS 设置语音识别内容的列表

#include "stdafx.h"
#include "RingBuffer.h"
#include <memory.h>


RingBuffer::RingBuffer()
{
	InitState();
}

void RingBuffer::InitState()
{

	m_bOwnerBuf = FALSE;
	m_pBuf		= 0;
	m_Size		= 0;
	m_ReadPos	= 0;
	m_WritePos	= 0;	
	InitializeCriticalSection(&m_mSecData);

}
RingBuffer::RingBuffer(unsigned int size)
{

	if(m_bOwnerBuf && m_pBuf)
	{
		delete[] m_pBuf;
		m_pBuf = NULL;
	}

	m_pBuf = new char[size];
	m_Size		= size;
	m_ReadPos	= 0;
	m_WritePos	= 0;

	InitializeCriticalSection(&m_mSecData);
}

RingBuffer::~RingBuffer()
{
	if(m_bOwnerBuf)
	{
		delete []m_pBuf;
	}
	m_pBuf = 0;

	DeleteCriticalSection(&m_mSecData);
}

void RingBuffer::Init(unsigned int size)
{
	if(m_pBuf == NULL)
	{
		m_pBuf = new char[size];
		m_Size = size;
		m_bOwnerBuf = TRUE;
	}
}

void RingBuffer::Init(char *data, unsigned int size, unsigned int start)
{
	if(m_bOwnerBuf && m_pBuf)
	{
		delete[] m_pBuf;
		m_pBuf = NULL;
	}
	if(m_pBuf == NULL)
	{
		m_pBuf = data;
		m_Size = size + 1;//空闲的要减1
		m_ReadPos	= 0;
		m_WritePos	= start;
		m_bOwnerBuf = FALSE;
	}
}

//----------------------------------------------------------------
// 写数据
//----------------------------------------------------------------
void RingBuffer::Write(char *data, long *plsize)
{
	unsigned int iSize=*plsize;
	Write(data,iSize);
	*plsize=iSize;
}


void RingBuffer::Write(char *data, unsigned int &size)
{
	EnterCriticalSection(&m_mSecData);

	if(m_WritePos >= m_ReadPos)
	{
		if(m_WritePos + size < m_Size)
		{
			
			memcpy(m_pBuf + m_WritePos, data, size);
			m_WritePos += size;
		}
		else
		{
			unsigned int rest;

			rest = (m_Size - 1) - m_WritePos;	

			//循环//足够的空间不追尾
			if(m_WritePos + size < m_Size + m_ReadPos)
			{
				memcpy(m_pBuf + m_WritePos, data, rest);
				memcpy(m_pBuf, data + rest, size - rest);
				m_WritePos = size - rest;
			}
			else
			{
				//写的速度快, 填充所有剩余空间,会丢弃一部分数据
				memcpy(m_pBuf + m_WritePos, data, rest);
				if(m_ReadPos > 0)//edit by jiujiu
				{
					memcpy(m_pBuf, data + rest, m_ReadPos-1);//减1避免追尾
					m_WritePos = m_ReadPos-1;//追尾了
					size = rest + m_ReadPos-1;
				}else
				{
					size = rest ;
				}
			}
		}
	}
	else
	{
		if(m_WritePos + size < m_ReadPos)//edit by jiujiu 去掉等于,不然下面就追尾
		{
			memcpy(m_pBuf + m_WritePos, data, size);

			m_WritePos += size;//追尾了///edit by jiujiu
		}
		else
		{
			//写的速度快, 填充所有剩余空间,会丢弃一部分数据
			//edit by jiujiu  追尾了
			if(m_ReadPos - m_WritePos > 0)
			{
				memcpy(m_pBuf + m_WritePos, data, m_ReadPos - m_WritePos-1);
				//m_WritePos = m_ReadPos;
				//size = m_WritePos;
				m_WritePos=m_ReadPos-1;//readpos为0就不可能成立m_ReadPos - m_WritePos > 0
				size = m_ReadPos - m_WritePos-1;
			}else
			{
				size = 0;
			}
		}
	}

	LeaveCriticalSection(&m_mSecData);

}

//----------------------------------------------------------------
// 读数据
//----------------------------------------------------------------

void RingBuffer::Read(char *data, unsigned int &size)
{
	EnterCriticalSection(&m_mSecData);
	if(m_ReadPos <= m_WritePos)
	{
		if(m_ReadPos + size <= m_WritePos)
		{
			if(data)
				memcpy(data, m_pBuf + m_ReadPos, size);
			m_ReadPos += size;
		}
		else
		{
			//读的速度快,读出所有数据
			size = m_WritePos - m_ReadPos;
			if(data)
				memcpy(data, m_pBuf + m_ReadPos, size);
			m_ReadPos = m_WritePos;
		}
	}
	else
	{
		if(m_ReadPos + size < m_Size)
		{
			if(data)
				memcpy(data, m_pBuf + m_ReadPos, size);
			m_ReadPos += size;
		}
		else
		{
			//循环
			unsigned int rest;
			rest = (m_Size - 1) - m_ReadPos;

			if(m_ReadPos + size < m_Size + m_WritePos)
			{
				if(data)
				{
					memcpy(data, m_pBuf + m_ReadPos, rest);
					memcpy(data + rest, m_pBuf, size - rest);
				}
				m_ReadPos = size - rest;
			}
			else
			{
				//读的速度快,读出所有数据
				if(data)
				{
					memcpy(data, m_pBuf + m_ReadPos, rest);
					memcpy(data + rest, m_pBuf, m_WritePos);
				}
				size = rest + m_WritePos;
				m_ReadPos = m_WritePos;
			}
		}
	}

	LeaveCriticalSection(&m_mSecData);
}

//----------------------------------------------------------------
// 得到剩余数据长度
//----------------------------------------------------------------
int	RingBuffer::DataSize()
{
	if(m_WritePos >= m_ReadPos)
	{
		return (m_WritePos - m_ReadPos);
	}
	else
	{
		return (m_Size - 1) - (m_ReadPos - m_WritePos);
	}
}

//----------------------------------------------------------------
// 得到剩余可用空间
//----------------------------------------------------------------

int RingBuffer::RestSize()
{
	EnterCriticalSection(&m_mSecData);
	int iRetSize;
	if(m_WritePos >= m_ReadPos)
	{
		iRetSize= (m_Size - 1) - (m_WritePos - m_ReadPos);
	}
	else
	{
		iRetSize=(m_ReadPos - m_WritePos);
	}

	if(iRetSize > 1)
		iRetSize-=1;

	LeaveCriticalSection(&m_mSecData);

	return iRetSize;
}

//----------------------------------------------------------------
// 清空数据
//----------------------------------------------------------------

void RingBuffer::Empty()
{	
	EnterCriticalSection(&m_mSecData);

	m_ReadPos	= 0;
	m_WritePos	= 0;

	LeaveCriticalSection(&m_mSecData);
}