void
StencilMapCanvas::Begin()
{
  if (!buffer_drawn) {
    ClearBuffer();
    buffer_drawn = true;
  }
}

bool CFile::Truncate() {
	if (m_iFD != -1 && ftruncate(m_iFD, 0) == 0) {
		ClearBuffer();
		return true;
	}

	return false;
}

void
MapDrawHelper::BufferRenderStart()
{
    if (!buffer_drawn) {
        ClearBuffer();
        buffer_drawn = true;
    }
}

	void TGBufferCanvas::Enable()
	{
		glEnable(GL_DEPTH_TEST);
 		BindFrameBuffer(m_frameBuffer);
 		glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
 		ClearBuffer();
		GLenum buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT ,GL_COLOR_ATTACHMENT3_EXT};
    	glDrawBuffers(4, buffers);
	}

SERIALISATION_INLINE void StreamWriter::Close()
{
    ClearBuffer();

    if (mFileStream.is_open())
    {
        mFileStream.close();
    }
}

CloHttpCurl::~CloHttpCurl(void)
{
	StopTransfer();
	ClearBuffer();
	ClearParam();

	delete m_pAssoc;
	m_pAssoc = NULL;
}

 ////////////////////////////////////////////////
 //
 // CStatEvents::CStatEvents
 //
 //
 //
 ////////////////////////////////////////////////
 CStatEvents::CStatEvents ( void )
     : m_bEnabled ( false )
     , m_ItemBuffer ( 0 )
     , m_BufferPos ( 0 )
     , m_BufferPosMax ( 0 )
     , m_BufferPosMaxUsing ( 0 )
 {
     ClearBuffer ( true );
 }

/*******************************************************************************
 BiquadFilterInit */
BiquadFilter*
BiquadFilterInit(const float *bCoeff, const float *aCoeff)
{

    // Allocate Memory
    BiquadFilter* filter = (BiquadFilter*)malloc(sizeof(BiquadFilter));

    if (filter)
    {
        // Initialize Buffers
        CopyBuffer(filter->b, bCoeff, 3);
        CopyBuffer(filter->a, aCoeff, 2);

        ClearBuffer(filter->x, 2);
        ClearBuffer(filter->y, 2);
        ClearBuffer(filter->w, 2);
    }
    return filter;
}

void CBuffer::Copy(CBuffer& buffer)
{
	int nReSize = buffer.GetMemSize();   //2048               2048
	int nSize = buffer.GetBufferLen();   //1025               0     1025
	ClearBuffer();
	if (ReAllocateBuffer(nReSize) == -1)
		return;
	CopyMemory(m_pBase,buffer.GetBuffer(),buffer.GetBufferLen());
	m_pPtr = m_pBase + nSize;
}

void CFile::Close() {
	if (m_iFD >= 0) {
		if (close(m_iFD) < 0) {
			DEBUG("CFile::Close(): close() failed with ["
					<< strerror(errno) << "]");
		}
	}
	m_iFD = -1;
	ClearBuffer();
}

HRESULT CMpcAudioRenderer::CreateDSBuffer()
{
	if (! m_pWaveFileFormat) return E_POINTER;

	HRESULT					hr				= S_OK;
	LPDIRECTSOUNDBUFFER		pDSBPrimary		= NULL;
	DSBUFFERDESC			dsbd;
	DSBUFFERDESC			cDSBufferDesc;
	DSBCAPS					bufferCaps;
	DWORD					dwDSBufSize		= m_pWaveFileFormat->nAvgBytesPerSec * 4;

	ZeroMemory(&bufferCaps, sizeof(bufferCaps));
	ZeroMemory(&dsbd, sizeof(DSBUFFERDESC));

	dsbd.dwSize        = sizeof(DSBUFFERDESC);
	dsbd.dwFlags       = DSBCAPS_PRIMARYBUFFER;
	dsbd.dwBufferBytes = 0;
	dsbd.lpwfxFormat   = NULL;
	if (SUCCEEDED (hr = m_pDS->CreateSoundBuffer( &dsbd, &pDSBPrimary, NULL )))
	{
		hr = pDSBPrimary->SetFormat(m_pWaveFileFormat);
		ATLASSERT(SUCCEEDED(hr));
		SAFE_RELEASE (pDSBPrimary);
	}


	SAFE_RELEASE (m_pDSBuffer);
	cDSBufferDesc.dwSize			= sizeof (DSBUFFERDESC);
	cDSBufferDesc.dwFlags			= DSBCAPS_GLOBALFOCUS			| 
									  DSBCAPS_GETCURRENTPOSITION2	| 
									  DSBCAPS_CTRLVOLUME 			|
									  DSBCAPS_CTRLPAN				|
									  DSBCAPS_CTRLFREQUENCY; 
	cDSBufferDesc.dwBufferBytes		= dwDSBufSize; 
	cDSBufferDesc.dwReserved		= 0; 
	cDSBufferDesc.lpwfxFormat		= m_pWaveFileFormat; 
   	cDSBufferDesc.guid3DAlgorithm	= GUID_NULL; 

	hr = m_pDS->CreateSoundBuffer (&cDSBufferDesc,  &m_pDSBuffer, NULL);

	m_nDSBufSize = 0;
	if (SUCCEEDED(hr))
	{
		bufferCaps.dwSize = sizeof(bufferCaps);
		hr = m_pDSBuffer->GetCaps(&bufferCaps);
	}
	if (SUCCEEDED (hr))
	{
		m_nDSBufSize = bufferCaps.dwBufferBytes;
		hr = ClearBuffer();
		m_pDSBuffer->SetFrequency ((long)(m_pWaveFileFormat->nSamplesPerSec * m_dRate));
	}

	return hr;
}

 void ReadTagName(char c)
 {
     if (IsWhitespace(c))
     {
         if (buffer == "a")
             state = State::ReadTag;
         else if (buffer == "!--")
             state = State::SkipComment;
         else
             state = State::SkipTag;
         ClearBuffer();
     }
     else if (c == '>')
     {
         state = State::Default;
         ClearBuffer();
     }
     else
         StoreToLower(c);
 }

void NoFile::Close()
{
    if (m_fd >= 0) {
        if (close(m_fd) < 0) {
            m_hadError = true;
            NO_DEBUG("NoFile::Close(): close() failed with [" << strerror(errno) << "]");
        }
    }
    m_fd = -1;
    ClearBuffer();
}

bool Mouse::SetCoopLevel(HWND hWnd)
{
	HRESULT result = _dDevice->SetCooperativeLevel(hWnd, DISCL_EXCLUSIVE | DISCL_FOREGROUND);
	if (FAILED(result))
	{
		SaveReleaseDevice();
		return false;
	}
	ClearBuffer();
	return true;
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	Copy
// 
// DESCRIPTION:	Copy from one buffer object to another...
// 
// RETURNS:	
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name				Date		Version		Comments
// N T ALMOND       270400		1.0			Origin
// 
////////////////////////////////////////////////////////////////////////////////
void CBuffer::Copy(CBuffer& buffer)
{
	int nReSize = buffer.GetMemSize();
	int nSize = buffer.GetBufferLen();
	ClearBuffer();
	ReAllocateBuffer(nReSize);

	m_pPtr = m_pBase + nSize;

	CopyMemory(m_pBase,buffer.GetBuffer(),buffer.GetBufferLen());
}

bool CFile::Seek(off_t uPos) {
	/* This sets errno in case m_iFD == -1 */
	errno = EBADF;

	if (m_iFD != -1 && lseek(m_iFD, uPos, SEEK_SET) == uPos) {
		ClearBuffer();
		return true;
	}
	m_bHadError = true;

	return false;
}

/**************************************************************************************
 * Function:    AllocateBuffers
 *
 * Description: allocate all the memory needed for the RA8 decoder
 *
 * Inputs:      none
 *
 * Outputs:     none
 *
 * Return:      pointer to Gecko2Info structure, set to all 0's
 **************************************************************************************/
Gecko2Info *AllocateBuffers(void)
{
	Gecko2Info *gi;

	/* create new Gecko2Info structure */
	gi = (Gecko2Info *)malloc(sizeof(Gecko2Info));
	if (!gi)
		return 0;
	ClearBuffer(gi, sizeof(Gecko2Info));	

	return gi;
}

 void SkipAttribute(char c)
 {
     if (c == '"')
     {
         if (buffer == "\"")
         {
             state = State::ReadTag;
             ClearBuffer();
         }
         else
             Store(c);
     }
 }

 void ReadTag(char c)
 {
     if (c == '=')
     {
         if (buffer == "href")
             state = State::ReadAttribute;
         else
             state = State::SkipAttribute;
         ClearBuffer();
     }
     else if (!IsWhitespace(c))
         StoreToLower(c);
 }

TEST(DSPSingle, TestStrideCopy)
{
    float out[10];
    float in1[5] = {1.,2.,3.,4.,5.};
    float in2[10] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};
    float ex1[10] = {1., 0., 2., 0., 3., 0., 4., 0., 5., 0.};
    float ex2[5] = {1., 3., 5., 7., 9.};
    
    ClearBuffer(out, 10);
    CopyBufferStride(out, 2, in1, 1, 5);
    for (unsigned i = 0; i < 10; ++i)
    {
        ASSERT_FLOAT_EQ(ex1[i], out[i]);
    }
    
    ClearBuffer(out, 10);
    CopyBufferStride(out, 1, in2, 2, 5);
    for (unsigned i = 0; i < 5; ++i)
    {
        ASSERT_FLOAT_EQ(ex2[i], out[i]);
    }
}