自学教程：C++ ClearBuffer函数代码示例

voidStencilMapCanvas::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;}

voidMapDrawHelper::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]);    }}

void FramebufferManagerCommon::Init() {	const std::string gameId = g_paramSFO.GetValueString("DISC_ID");	// This applies a hack to Dangan Ronpa, its demo, and its sequel.	// The game draws solid colors to a small framebuffer, and then reads this directly in VRAM.	// We force this framebuffer to 1x and force download it automatically.	hackForce04154000Download_ = gameId == "NPJH50631" || gameId == "NPJH50372" || gameId == "NPJH90164" || gameId == "NPJH50515";	// And an initial clear. We don't clear per frame as the games are supposed to handle that	// by themselves.	ClearBuffer();	BeginFrame();}

/******************************************************************************* Set Speed */Error_tTapeSetSpeed(Tape* tape, TapeSpeed speed){        if (tape)    {        // Set speed        tape->speed = speed;                // Update saturation curve        PolySaturatorSetN(tape->polysat, calculate_n(tape->saturation, speed));                // Clear old flutter/wow modulation waveform        ClearBuffer(tape->flutter_mod, tape->flutter_mod_length); // Yes, clear the old length...                // Calculate new modulation waveform length...        tape->flutter_mod_length = (unsigned)(tape->sample_rate / /                                              (0.80 * powf(2.0, (float)speed)));                // Generate flutter/wow modulation waveform        float temp_buffer[tape->flutter_mod_length];        for (unsigned comp = 0; comp < N_FLUTTER_COMPONENTS; ++comp)        {            float phase_step = (2.0 * M_PI * comp * powf(2.0, (float)speed)) / tape->sample_rate;            ClearBuffer(temp_buffer, tape->flutter_mod_length);            for (unsigned i = 0; i < tape->flutter_mod_length; ++i)            {                temp_buffer[i] = sinf(i * phase_step) / N_FLUTTER_COMPONENTS;            }            VectorVectorAdd(tape->flutter_mod, tape->flutter_mod,                            temp_buffer, tape->flutter_mod_length);        }        return NOERR;;    }    else    {        return NULL_PTR_ERROR;    }}

bool NoFile::Seek(off_t pos){    /* This sets errno in case m_iFD == -1 */    errno = EBADF;    if (m_fd != -1 && lseek(m_fd, pos, SEEK_SET) == pos) {        ClearBuffer();        return true;    }    m_hadError = true;    return false;}

STDMETHODIMP CMpcAudioRenderer::Run(REFERENCE_TIME tStart){    HRESULT		hr;    if (m_State == State_Running) {        return NOERROR;    }    if (m_useWASAPI) {        hr=CheckAudioClient(m_pWaveFileFormat);        if (FAILED(hr)) {            TRACE(_T("CMpcAudioRenderer::Run Error on check audio client/n"));            return hr;        }        // Rather start the client at the last moment when the buffer is fed        /*hr = pAudioClient->Start();        if (FAILED (hr))        {        TRACE(_T("CMpcAudioRenderer::Run Start error"));        return hr;        }*/    } else {        if (m_pDSBuffer &&                m_pPosition &&                m_pWaveFileFormat &&                SUCCEEDED(m_pPosition->GetRate(&m_dRate))) {            if (m_dRate < 1.0) {                hr = m_pDSBuffer->SetFrequency ((long)(m_pWaveFileFormat->nSamplesPerSec * m_dRate));                if (FAILED (hr)) {                    return hr;                }            } else {                hr = m_pDSBuffer->SetFrequency ((long)m_pWaveFileFormat->nSamplesPerSec);                m_pSoundTouch->setRateChange((float)(m_dRate-1.0)*100);                if (m_bMuteFastForward) {                    if (m_dRate == 1.0) {                        m_pDSBuffer->SetVolume(m_lVolume);                    } else {                        m_pDSBuffer->SetVolume(DSBVOLUME_MIN);                    }                }            }        }        ClearBuffer();    }    hr = CBaseRenderer::Run(tStart);    return hr;}

void CChan::SendBuffer(CClient* pClient) {	if (m_pNetwork && m_pNetwork->IsUserAttached()) {		// in the event that pClient is NULL, need to send this to all clients for the user		// I'm presuming here that pClient is listed inside vClients thus vClients at this		// point can't be empty.		//		// This loop has to be cycled twice to maintain the existing behavior which is		// 1. OnChanBufferStarting		// 2. OnChanBufferPlayLine		// 3. ClearBuffer() if not keeping the buffer		// 4. OnChanBufferEnding		//		// With the exception of ClearBuffer(), this needs to happen per client, and		// if pClient is not NULL, the loops break after the first iteration.		//		// Rework this if you like ...		if (!m_Buffer.IsEmpty()) {			const vector<CClient*> & vClients = m_pNetwork->GetClients();			for (size_t uClient = 0; uClient < vClients.size(); ++uClient) {				CClient * pUseClient = (pClient ? pClient : vClients[uClient]);				bool bSkipStatusMsg = false;				NETWORKMODULECALL(OnChanBufferStarting(*this, *pUseClient), m_pNetwork->GetUser(), m_pNetwork, NULL, bSkipStatusMsg = true);				if (!bSkipStatusMsg) {					m_pNetwork->PutUser(":***[email
C++ ClearCache函数代码示例
C++ ClearBits函数代码示例