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;
}
bool CFile::Seek(off_t uPos) {
if (m_iFD != -1 && lseek(m_iFD, uPos, SEEK_SET) == uPos) {
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]);
}
}
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();
}
TEST(DSPSingle, TestClearBuffer)
{
float out[10];
for (unsigned i = 0; i < 10; ++i)
{
out[i] = i;
}
ClearBuffer(out, 10);
for (unsigned i = 0; i < 10; ++i)
{
ASSERT_FLOAT_EQ(0.0, out[i]);
}
}
bool CFile::Truncate() {
/* This sets errno in case m_iFD == -1 */
errno = EBADF;
if (m_iFD != -1 && ftruncate(m_iFD, 0) == 0) {
ClearBuffer();
return true;
}
m_bHadError = true;
return false;
}
/*******************************************************************************
Set Speed */
Error_t
TapeSetSpeed(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 protected] PRIVMSG " + GetName() + " :Buffer Playback...", pUseClient);
}
unsigned int uSize = m_Buffer.Size();
for (unsigned int uIdx = 0; uIdx < uSize; uIdx++) {
CString sLine = m_Buffer.GetLine(uIdx, *pUseClient);
NETWORKMODULECALL(OnChanBufferPlayLine(*this, *pUseClient, sLine), m_pNetwork->GetUser(), m_pNetwork, NULL, continue);
m_pNetwork->PutUser(sLine, pUseClient);
}
bSkipStatusMsg = false;
NETWORKMODULECALL(OnChanBufferEnding(*this, *pUseClient), m_pNetwork->GetUser(), m_pNetwork, NULL, bSkipStatusMsg = true);
if (!bSkipStatusMsg) {
m_pNetwork->PutUser(":***[email protected] PRIVMSG " + GetName() + " :Playback Complete.", pUseClient);
}
if (pClient)
break;
}
if (!KeepBuffer()) {
ClearBuffer();
}
}
}
}
/**************************************************************************************
* Function: AllocateBuffers
*
* Description: allocate all the memory needed for the MP3 decoder
*
* Inputs: none
*
* Outputs: none
*
* Return: pointer to MP3DecInfo structure (initialized with pointers to all
* the internal buffers needed for decoding, all other members of
* MP3DecInfo structure set to 0)
*
* Notes: if one or more mallocs fail, function frees any buffers already
* allocated before returning
**************************************************************************************/
MP3DecInfo *AllocateBuffers(void)
{
MP3DecInfo *mp3DecInfo;
FrameHeader *fh;
SideInfo *si;
ScaleFactorInfo *sfi;
HuffmanInfo *hi;
DequantInfo *di;
IMDCTInfo *mi;
SubbandInfo *sbi;
mp3DecInfo = (MP3DecInfo *)malloc(sizeof(MP3DecInfo));
if (!mp3DecInfo)
return 0;
ClearBuffer(mp3DecInfo, sizeof(MP3DecInfo));
fh = (FrameHeader *) malloc(sizeof(FrameHeader));
si = (SideInfo *) malloc(sizeof(SideInfo));
sfi = (ScaleFactorInfo *) malloc(sizeof(ScaleFactorInfo));
hi = (HuffmanInfo *) malloc(sizeof(HuffmanInfo));
di = (DequantInfo *) malloc(sizeof(DequantInfo));
mi = (IMDCTInfo *) malloc(sizeof(IMDCTInfo));
sbi = (SubbandInfo *) malloc(sizeof(SubbandInfo));
mp3DecInfo->FrameHeaderPS = (void *)fh;
mp3DecInfo->SideInfoPS = (void *)si;
mp3DecInfo->ScaleFactorInfoPS = (void *)sfi;
mp3DecInfo->HuffmanInfoPS = (void *)hi;
mp3DecInfo->DequantInfoPS = (void *)di;
mp3DecInfo->IMDCTInfoPS = (void *)mi;
mp3DecInfo->SubbandInfoPS = (void *)sbi;
if (!fh || !si || !sfi || !hi || !di || !mi || !sbi) {
FreeBuffers(mp3DecInfo); /* safe to call - only frees memory that was successfully allocated */
return 0;
}
/* important to do this - DSP primitives assume a bunch of state variables are 0 on first use */
ClearBuffer(fh, sizeof(FrameHeader));
ClearBuffer(si, sizeof(SideInfo));
ClearBuffer(sfi, sizeof(ScaleFactorInfo));
ClearBuffer(hi, sizeof(HuffmanInfo));
ClearBuffer(di, sizeof(DequantInfo));
ClearBuffer(mi, sizeof(IMDCTInfo));
ClearBuffer(sbi, sizeof(SubbandInfo));
return mp3DecInfo;
}
void crtaj_polje(tetris_data *data)
{
int i, j;
ClearBuffer(data);
for(i = 0; i < VPOLJA+1; i++)
for(j = 0; j < SPOLJA+1; j++)
if(data->polje[i+1][j+1])
{
BitBlt(data->hdcBuffer, j*VELBLOKA, i*VELBLOKA, VELBLOKA, VELBLOKA, data->hdcFigure, data->polje[i+1][j+1]*VELBLOKA, VELBLOKA, SRCAND);
BitBlt(data->hdcBuffer, j*VELBLOKA, i*VELBLOKA, VELBLOKA, VELBLOKA, data->hdcFigure, data->polje[i+1][j+1]*VELBLOKA, 0, SRCPAINT);
}
}
