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