void AxString::Replace(const char *pTarget, const char *pSubs, bool bAll, int iOffset) { if (AX_ISZERO(pTarget)) return ; unsigned int iTargetLen = strlen(pTarget); unsigned int iSubsLen = AX_ISZERO(pSubs) ? 0 : strlen(pSubs); if (GetSize() < iTargetLen) return; do { int pos = Find(pTarget, iOffset); if (AxString::npos == pos) return ; // splice unsigned int iNewLen = GetSize() - iTargetLen + iSubsLen; if (GetBufferSize() <= iNewLen) { Resize( GetBufferSize() * 2 ); } if ((pos+iTargetLen) < GetSize()) { memmove((void*)(c_str()+pos+iSubsLen), (void*)(c_str()+pos+iTargetLen), GetSize()-pos-iTargetLen+1); } memcpy(m_pByteArray+pos, pSubs, iSubsLen); m_pByteArray[iNewLen] = '\0'; m_iDataLength = iNewLen; iOffset = pos + iSubsLen; } while (bAll); }
TemporaryRef<gfx::DataSourceSurface> BufferTextureHost::GetAsSurface() { RefPtr<gfx::DataSourceSurface> result; if (mFormat == gfx::SurfaceFormat::UNKNOWN) { NS_WARNING("BufferTextureHost: unsupported format!"); return nullptr; } else if (mFormat == gfx::SurfaceFormat::YUV) { YCbCrImageDataDeserializer yuvDeserializer(GetBuffer(), GetBufferSize()); if (!yuvDeserializer.IsValid()) { return nullptr; } result = yuvDeserializer.ToDataSourceSurface(); if (NS_WARN_IF(!result)) { return nullptr; } } else { ImageDataDeserializer deserializer(GetBuffer(), GetBufferSize()); if (!deserializer.IsValid()) { NS_ERROR("Failed to deserialize image!"); return nullptr; } result = deserializer.GetAsSurface(); } return result.forget(); }
///////////////////////////////////////////////////////////////////////// // 원하는 길이만큼 읽기위치 에서 삭제. // // Parameters: 없음. // Return: 없음. ///////////////////////////////////////////////////////////////////////// void CAyaStreamSQ::RemoveData(int iSize) { if (GetUseSize() < iSize) return; else { if (m_iReadPos + iSize >= GetBufferSize()) m_iReadPos = (m_iReadPos + iSize) % GetBufferSize(); else m_iReadPos += iSize; } }
///////////////////////////////////////////////////////////////////////// // 현재 버퍼에 남은 용량 얻기. // // Parameters: 없음. // Return: (int)남은용량. ///////////////////////////////////////////////////////////////////////// int CAyaStreamSQ::GetFreeSize(void) { if (m_iReadPos != m_iWritePos){ if (m_iReadPos >= m_iWritePos) return m_iReadPos - m_iWritePos - 1; else return GetBufferSize() - m_iWritePos + m_iReadPos - 1; } else return GetBufferSize() - 1; }
///////////////////////////////////////////////////////////////////////// // Write 의 위치를 이동하는 함수. // // Parameters: 없음. // Return: (int)Write 이동 사이즈 ///////////////////////////////////////////////////////////////////////// int CAyaStreamSQ::MoveWritePos(int iSize) { if (GetFreeSize() < iSize) return 0; else { if (m_iWritePos + iSize >= GetBufferSize()) m_iWritePos = (m_iWritePos + iSize) % GetBufferSize(); else m_iWritePos += iSize; } return iSize; }
CAmxxReader::Error CAmxxReader::GetSection(void *buffer) { if (!m_pFile) return m_Status; if (m_AmxxFile) { PluginEntry *pe = &(m_Bh.plugins[m_Entry]); char *tempBuffer = new char[m_SectionLength + 1]; fseek(m_pFile, pe->offs, SEEK_SET); DATAREAD((void *)tempBuffer, 1, m_SectionLength); uLongf destLen = GetBufferSize(); int result = uncompress((Bytef *)buffer, &destLen, (Bytef *)tempBuffer, m_SectionLength); delete [] tempBuffer; if (result != Z_OK) { AMXXLOG_Log("[AMXX] Zlib error encountered: %d(%d)", result, m_SectionLength); m_Status = Err_Decompress; return Err_Decompress; } return Err_None; } else { // new file type: go to the section table entry fseek(m_pFile, m_SectionHdrOffset, SEEK_SET); // go to the offset TableEntry entry; DATAREAD(&entry, sizeof(entry), 1); fseek(m_pFile, entry.offset, SEEK_SET); uLongf destLen = GetBufferSize(); // read the data to a temporary buffer char *tempBuffer = new char[m_SectionLength + 1]; //fread(tempBuffer, sizeof(char), m_SectionLength, m_pFile); DATAREAD((void*)tempBuffer, 1, m_SectionLength); // decompress int result = uncompress((Bytef *)buffer, &destLen, (Bytef *)tempBuffer, m_SectionLength); delete [] tempBuffer; if (result != Z_OK) { AMXXLOG_Log("[AMXX] Zlib error encountered: %d(%d)", result, m_SectionLength); m_Status = Err_Decompress; return Err_Decompress; } return Err_None; } }
void BufferTextureHost::InitSize() { if (mFormat == gfx::SurfaceFormat::YUV) { YCbCrImageDataDeserializer yuvDeserializer(GetBuffer(), GetBufferSize()); if (yuvDeserializer.IsValid()) { mSize = yuvDeserializer.GetYSize(); } } else if (mFormat != gfx::SurfaceFormat::UNKNOWN) { ImageDataDeserializer deserializer(GetBuffer(), GetBufferSize()); if (deserializer.IsValid()) { mSize = deserializer.GetSize(); } } }
void FSlateElementIndexBuffer::FillBuffer( const TArray<SlateIndex>& InIndices, bool bShrinkToFit ) { check( IsInRenderingThread() ); if( InIndices.Num() ) { uint32 NumIndices = InIndices.Num(); uint32 RequiredBufferSize = NumIndices*sizeof(SlateIndex); // resize if needed if( RequiredBufferSize > GetBufferSize() || bShrinkToFit ) { // Use array resize techniques for the vertex buffer ResizeBuffer( InIndices.GetAllocatedSize() ); } BufferUsageSize += RequiredBufferSize; void* IndicesPtr = RHILockIndexBuffer( IndexBufferRHI, 0, RequiredBufferSize, RLM_WriteOnly ); FMemory::Memcpy( IndicesPtr, InIndices.GetData(), RequiredBufferSize ); RHIUnlockIndexBuffer(IndexBufferRHI); } }
Error EventBuffer::BeginRead(void *&pBuffer, size_t iBytesWanted) { BufferEvent *pEvent; int iReadIndex; size_t iMaxBytes; pEvent = m_pQueue->Peek(); iReadIndex = GetReadIndex(); if (pEvent && pEvent->iIndex == iReadIndex) { return kError_EventPending; } if (!pEvent) { return PullBuffer::BeginRead(pBuffer, iBytesWanted); } if (pEvent->iIndex > iReadIndex) { iMaxBytes = pEvent->iIndex - iReadIndex; } else { iMaxBytes = (GetBufferSize() - iReadIndex) + pEvent->iIndex; } if (iBytesWanted >= iMaxBytes) return kError_EventPending; else return PullBuffer::BeginRead(pBuffer, iBytesWanted); }
//**************************************************************************** // //! checks how much buffer is Empty. //! //! \param pCircularBuffer is a pointer to the control structure for Circular. //! Buffer. //! //! This function //! 1. Retreives the amount of Buffer Empty. //! //! \return the amount of buffer Empty. // //**************************************************************************** unsigned int GetBufferEmptySize(tCircularBuffer *pCircularBuffer) { unsigned int uiBufferFilled; uiBufferFilled = GetBufferSize(pCircularBuffer); return (pCircularBuffer->ulBufferSize - uiBufferFilled); }
int CAyaStreamSQ::GetNotBrokenPutSize(void) { if (m_iWritePos < m_iReadPos) return GetBufferSize() - m_iWritePos; else return GetFreeSize(); }
///////////////////////////////////////////////////////////////////////// // 현재 사용중인 용량 얻기. // // Parameters: 없음. // Return: (int)사용중인 용량. ///////////////////////////////////////////////////////////////////////// int CAyaStreamSQ::GetUseSize(void) { if (m_iWritePos >= m_iReadPos) return m_iWritePos - m_iReadPos; else return GetBufferSize() - m_iReadPos + m_iWritePos; }
///////////////////////////////////////////////////////////////////////// // 버퍼의 모든 데이타 삭제. // // Parameters: 없음. // Return: 없음. ///////////////////////////////////////////////////////////////////////// void CAyaStreamSQ::ClearBuffer(void) { for (int iCnt = 0; iCnt < GetBufferSize(); iCnt++) { m_chpBuffer[iCnt] = 0; } }
void SMTPClientConnection::StartSendFile_(const String &sFilename) { try { current_file_.Open(sFilename, File::OTReadOnly); } catch (...) { String sErrorMsg; sErrorMsg.Format(_T("Could not send file %s via socket since it does not exist."), sFilename.c_str()); ErrorManager::Instance()->ReportError(ErrorManager::High, 5019, "SMTPClientConnection::_SendFileContents", sErrorMsg); return; } transmission_buffer_.Initialize(shared_from_this()); std::shared_ptr<ByteBuffer> pBuf = current_file_.ReadChunk(GetBufferSize()); if (pBuf->GetSize() == 0) return; BYTE *pSendBuffer = (BYTE*) pBuf->GetBuffer(); size_t iSendBufferSize = pBuf->GetSize(); // Append the transmission buffer transmission_buffer_.Append(pSendBuffer, iSendBufferSize); ReadAndSend_(); }
//---------------------------------------------------------------------------- //! @brief バックバッファへのポインタを取得します。 //! @param buff : バックバッファへのポインタを返すためのバッファへのポインタ //! @param size : バッファのサイズを返す変数へのポインタ //! @return エラーコード //---------------------------------------------------------------------------- HRESULT TBufferRenderer::GetBackBuffer( BYTE **buff, long *size ) { CAutoLock cAutoLock(&m_BufferLock); // クリティカルセクション *buff = GetBackBuffer(); *size = GetBufferSize(); return S_OK; }
static int sendMessage(EMBX_VOID *message) { int *typedMessage = (int *) message; EMBX_UINT size; int stop; int portIndex; EMBX_ERROR err; /* get the size of the current message */ EMBX(GetBufferSize(message, &size)); /* get the number of the current stop */ stop = typedMessage[0]; assert(stop <= NUM_STOPS); if (stop == NUM_STOPS) { return 0; } /* determine the port that this message is next due * to stop at */ portIndex = typedMessage[stop + 1]; /* update the current stop index */ typedMessage[0] = stop + 1; VERBOSE(printf("Sending message to portIndex %d\n", portIndex)); /* finally send the message to the next stop */ err = EMBX_I(SendMessage(outPort[portIndex], message, size)); assert(EMBX_SUCCESS == err || EMBX_INVALID_PORT == err); return 1; }
void CCoreAudioDevice::Close() { if (!m_DeviceId) return; // Stop the device if it was started Stop(); // Unregister the IOProc if we have one RemoveIOProc(); SetHogStatus(false); CCoreAudioHardware::SetAutoHogMode(false); if (m_MixerRestore > -1) // We changed the mixer status SetMixingSupport((m_MixerRestore ? true : false)); m_MixerRestore = -1; if (m_SampleRateRestore != 0.0f) SetNominalSampleRate(m_SampleRateRestore); if (m_BufferSizeRestore && m_BufferSizeRestore != GetBufferSize()) { SetBufferSize(m_BufferSizeRestore); m_BufferSizeRestore = 0; } m_IoProc = NULL; m_DeviceId = 0; m_ObjectListenerProc = NULL; }
void SMTPClientConnection::_StartSendFile(const String &sFilename) { if (!_currentFile.Open(sFilename, File::OTReadOnly)) { String sErrorMsg; sErrorMsg.Format(_T("Could not send file %s via socket since it does not exist."), sFilename); ErrorManager::Instance()->ReportError(ErrorManager::High, 5019, "SMTPClientConnection::_SendFileContents", sErrorMsg); return; } _transmissionBuffer.Initialize(this); shared_ptr<ByteBuffer> pBuf = _currentFile.ReadChunk(GetBufferSize()); if (!pBuf) return; BYTE *pSendBuffer = (BYTE*) pBuf->GetBuffer(); int iSendBufferSize = pBuf->GetSize(); // Append the transmission buffer _transmissionBuffer.Append(pSendBuffer, iSendBufferSize); _ReadAndSend(); }
_Must_inspect_result_ NTSTATUS ValidateMemoryOffsets( __in_opt PWDFMEMORY_OFFSET Offsets ) { NTSTATUS status; size_t total; if (Offsets == NULL) { return STATUS_SUCCESS; } status = RtlSizeTAdd(Offsets->BufferLength, Offsets->BufferOffset, &total); if (!NT_SUCCESS(status)) { return status; } if (total > GetBufferSize()) { return STATUS_INTEGER_OVERFLOW; } return STATUS_SUCCESS; }
bool UIOpenGLTextures::ClearTexture(GLTexture *Texture) { if (!Texture) return false; if (Texture->m_type == GL_TEXTURE_CUBE_MAP) return false; QSize size = Texture->m_size; uint buffsize = GetBufferSize(size, Texture->m_dataFmt, Texture->m_dataType); if (!buffsize) return false; unsigned char *scratch = new unsigned char[buffsize]; if (!scratch) return false; memset(scratch, 0, buffsize); glTexImage2D(Texture->m_type, 0, Texture->m_internalFmt, size.width(), size.height(), 0, Texture->m_dataFmt, Texture->m_dataType, scratch); delete [] scratch; return true; }
void PacketBuffer::ReArrange() { const uint16 bufferSize = GetBufferSize(); MoveMemory(buffer.data(), GetBuffer(), bufferSize); readPos = 0; writePos = bufferSize; }
/*** void UdpServer::resumeListening(void) ** ** Synopsis: ** Resumes listening on a UdpServer that did a StopListening ** ** Parameters: ** None ** ** Return Values: ** None ** ** Errors: ** None ** ** Notes: ** ** If StartListening was never called, this does nothing ** If it is already listening, it does nothing */ void UdpServer::resumeListening(void) { if(!_fStarted) { return; } // say we want to listen, may fail, but we will pick it up when we can. _fListening = true; // make sure we have room to to put our handle in if(_cPending >= _cPendingMax) { return; } // if we need to start listening on a socket if(_rghUDP[_cPending] >= INVALID_UDP_SOCKET) { // do not need to check to see if Ethernet is initialized because I can assign sockets before then _rghUDP[_cPending] = UDPOpen(_localPort, NULL, 0); if(_rghUDP[_cPending] < INVALID_UDP_SOCKET) { // As for the iBuff, when we get data on the socket, the last entry // will be where we put pending Client so just use this iBuff as the cache buffer ExchangeCacheBuffer(_rghUDP[_cPending], GetBufferLocation(_cPending), GetBufferSize()); } } }
bool CCoreAudioDevice::SetBufferSize(UInt32 size) { if (!m_DeviceId) return false; AudioObjectPropertyAddress propertyAddress; propertyAddress.mScope = kAudioDevicePropertyScopeOutput; propertyAddress.mElement = 0; propertyAddress.mSelector = kAudioDevicePropertyBufferFrameSize; UInt32 propertySize = sizeof(size); OSStatus ret = AudioObjectSetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, propertySize, &size); if (ret != noErr) { CLog::Log(LOGERROR, "CCoreAudioDevice::SetBufferSize: " "Unable to set buffer size. Error = %s", GetError(ret).c_str()); } if (GetBufferSize() != size) CLog::Log(LOGERROR, "CCoreAudioDevice::SetBufferSize: Buffer size change not applied."); else CLog::Log(LOGDEBUG, "CCoreAudioDevice::SetBufferSize: Set buffer size to %d", (int)size); return (ret == noErr); }
bool CCoreAudioDevice::Open(AudioDeviceID deviceId) { m_DeviceId = deviceId; m_BufferSizeRestore = GetBufferSize(); CLog::Log(LOGDEBUG, "CCoreAudioDevice::Open: Opened device 0x%04x", (uint)m_DeviceId); return true; }
/** * Send a sound clip to the audio subsystem. */ void WriteSound(int32 *buf, int Count) { //extern int EmulationPaused; SDL_LockAudio(); /*if (EmulationPaused == 0)*/ { // for some reason EmulationPaused is always 1, ignore it while(Count) { if(s_BufferIn == s_BufferSize) goto _exit; s_Buffer[s_BufferWrite] = *buf; Count--; s_BufferWrite = (s_BufferWrite + 1) % s_BufferSize; s_BufferIn++; buf++; } } _exit: SDL_UnlockAudio(); // If we have too much audio, wait a bit before accepting more. // This keeps the lag in check. while (GetBufferedSound() > 3 * GetBufferSize()) usleep(1000); }
void ff::BufferCache::ReturnBuffer(ID3D11Buffer *pBuffer) { assertRet(pBuffer); size_t nBytes = GetBufferSize(pBuffer); size_t nBuffer = GetBufferIndex(nBytes); _buffers[nBuffer].Insert(pBuffer); }
/* BufferPoolCreate * Creates a new buffer-pool from the given buffer object. * This allows sub-allocations from a buffer-object. */ OsStatus_t BufferPoolCreate( _In_ DmaBuffer_t* Buffer, _Out_ BufferPool_t** Pool) { // Allocate the pool *Pool = (BufferPool_t*)malloc(sizeof(BufferPool_t)); (*Pool)->Buffer = Buffer; return bpool((void*)GetBufferDataPointer(Buffer), GetBufferSize(Buffer), &(*Pool)->Pool); }
//---------------------------------------------------------------------------- //! @brief Graph connection has been made. //! @param pmt : メディア タイプを指定する CMediaType オブジェクトへのポインタ //! @return エラーコード //---------------------------------------------------------------------------- HRESULT TBufferRenderer::SetMediaType( const CMediaType *pmt ) { CAutoLock cAutoLock(&m_BufferLock); // クリティカルセクション // Retrive the size of this media type VIDEOINFO *pviBmp; // Bitmap info header pviBmp = (VIDEOINFO *)pmt->Format(); m_VideoWidth = pviBmp->bmiHeader.biWidth; m_VideoHeight = abs(pviBmp->bmiHeader.biHeight); m_VideoPitch = m_VideoWidth * 4; // RGB32に決め打ち if( !IsAllocatedFrontBuffer() ) AllocFrontBuffer( GetBufferSize() ); if( !IsAllocatedBackBuffer() ) AllocBackBuffer( GetBufferSize() ); return S_OK; }
void* Buff::GetBuffer() { if(m_pBuffer==NULL){ System* pSys = static_cast<System*>(m_pFactoryMgr); D3DFORMAT fmt = ( GetElementSize() == 4 )?D3DFMT_INDEX32 :D3DFMT_INDEX16; D3DPOOL pool = ( m_Info.usage == enUSAGE_DYNAMIC )?D3DPOOL_DEFAULT :D3DPOOL_MANAGED; DWORD dwUsage = ( m_Info.usage == enUSAGE_DYNAMIC )?D3DUSAGE_DYNAMIC :0; HRESULT hr = pSys->GetDevice()->CreateIndexBuffer(GetBufferSize(),dwUsage,fmt,pool,&m_pBuffer,NULL); } if(!m_bDirty) return m_pBuffer; if(m_Info.InitData!=NULL){ void* pDest = NULL; enumBufferFillState state = enBFS_OK; HRESULT hr = m_pBuffer->Lock(0,GetBufferSize(),(void**)&pDest,D3DLOCK_DISCARD); if(hr == S_OK){ memcpy(pDest,m_Info.InitData,GetBufferSize()); m_pBuffer->Unlock(); SAF_DA(m_Info.InitData); m_bDirty = false; return m_pBuffer; } }else if(m_Info.pCB!=NULL){ if(m_Info.pCB->IsLoad(this)){ void* pOutBuffer = NULL; U32 uiBufferSize = GetBufferSize(); HRESULT hr = m_pBuffer->Lock(0,uiBufferSize,(void**)&pOutBuffer,D3DLOCK_DISCARD); if(SUCCEEDED(hr)){ m_Info.pCB->OnFill(pOutBuffer,uiBufferSize,this); m_pBuffer->Unlock(); m_bDirty = false; return m_pBuffer; } } } return NULL; }
double EffectPaulstretch::CalcPreviewInputLength(double previewLength) { // FIXME: Preview is currently at the project rate, but should really be // at the track rate (bugs 1284 and 852). auto minDuration = GetBufferSize(mProjectRate) * 2 + 1; // Preview playback may need to be trimmed but this is the smallest selection that we can use. double minLength = std::max<double>(minDuration / mProjectRate, previewLength / mAmount); return minLength; }