NSCAPI::nagiosReturn nscapi::core_wrapper::query(const std::wstring & command, const std::string & request, std::string & result)
{
if (!fNSAPIInject)
throw nscapi::nscapi_exception("NSCore has not been initiated...");
char *buffer = NULL;
unsigned int buffer_size = 0;
NSCAPI::nagiosReturn retC = query(command.c_str(), request.c_str(), request.size(), &buffer, &buffer_size);
if (buffer_size > 0 && buffer != NULL) {
//PluginCommand::ResponseMessage rsp_msg;
result = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
switch (retC) {
case NSCAPI::returnIgnored:
CORE_LOG_ERROR_STD(_T("No handler for command '") + command + _T("'."));
break;
case NSCAPI::returnOK:
case NSCAPI::returnCRIT:
case NSCAPI::returnWARN:
case NSCAPI::returnUNKNOWN:
break;
default:
throw nscapi::nscapi_exception("Unknown return code from query: " + utf8::cvt<std::string>(command));
}
return retC;
}
void GMPPlaneImpl::DoneWithAPI() {
DestroyBuffer();
// Do this after destroying the buffer because destruction
// involves deallocation, which requires a host.
mHost = nullptr;
}
const GrVkBuffer::Resource* GrVkBuffer::Create(const GrVkGpu* gpu, const Desc& desc) {
VkBuffer buffer;
GrVkAlloc alloc;
// create the buffer object
VkBufferCreateInfo bufInfo;
memset(&bufInfo, 0, sizeof(VkBufferCreateInfo));
bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufInfo.flags = 0;
bufInfo.size = desc.fSizeInBytes;
switch (desc.fType) {
case kVertex_Type:
bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
break;
case kIndex_Type:
bufInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
break;
case kUniform_Type:
bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
break;
case kCopyRead_Type:
bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
break;
case kCopyWrite_Type:
bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
break;
case kTexel_Type:
bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
}
if (!desc.fDynamic) {
bufInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
}
bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
bufInfo.queueFamilyIndexCount = 0;
bufInfo.pQueueFamilyIndices = nullptr;
VkResult err;
err = VK_CALL(gpu, CreateBuffer(gpu->device(), &bufInfo, nullptr, &buffer));
if (err) {
return nullptr;
}
if (!GrVkMemory::AllocAndBindBufferMemory(gpu,
buffer,
desc.fType,
desc.fDynamic,
&alloc)) {
return nullptr;
}
const GrVkBuffer::Resource* resource = new GrVkBuffer::Resource(buffer, alloc, desc.fType);
if (!resource) {
VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
GrVkMemory::FreeBufferMemory(gpu, desc.fType, alloc);
return nullptr;
}
return resource;
}
void CIOBuffer::Allocator::Release(
CIOBuffer *pBuffer)
{
if (!pBuffer)
{
throw CException(_T("CIOBuffer::Allocator::Release()"), _T("pBuffer is null"));
}
CCriticalSection::Owner lock(m_criticalSection);
//lint -e{1933} call to unqualified virtual function
OnBufferReleased();
// unlink from the in use list
pBuffer->RemoveFromList();
if (m_maxFreeBuffers == 0 ||
m_freeList.Count() < m_maxFreeBuffers)
{
pBuffer->Empty();
// add to the free list
m_freeList.PushNode(pBuffer);
}
else
{
DestroyBuffer(pBuffer);
}
}
LPDIRECTSOUND CDXSound::Create( HWND hwnd, DWORD dwLevel )
{
HRESULT hr;
m_hWnd = hwnd;
m_lpDS = NULL;
hr = DirectSoundCreate( NULL, &m_lpDS, NULL );
if( hr != DS_OK )
return m_lpDS;
hr = m_lpDS->SetCooperativeLevel( hwnd, dwLevel );//DSSCL_NORMAL );
if ( hr != DS_OK )
{
m_lpDS->Release();
m_lpDS = NULL;
}
else if ( !CreateBuffer() )
{
DestroyBuffer();
m_lpDS->Release();
m_lpDS = NULL;
}
return m_lpDS;
}
GMPPlaneImpl::~GMPPlaneImpl()
{
DestroyBuffer();
if (mHost) {
mHost->PlaneDestroyed(this);
}
}
void CDXSound::ChangeSampleRate(unsigned int nSampleRate)
{
if ( nSampleRate != 44100 && nSampleRate != 22050 && nSampleRate != 11025 )
return;
if ( nSampleRate == m_nSampleRate )
return;
DestroyBuffer();
m_nSampleRate = nSampleRate;
CreateBuffer();
stPSG *st;
st = m_stPSG;
while( st )
{
st->psg->ChangeSampleRate();
st = st->next;
}
if ( m_bPlay )
{
m_bPlay = FALSE;
Resume();
}
}
GMPErr
GMPPlaneImpl::MaybeResize(int32_t aNewSize) {
if (aNewSize <= AllocatedSize()) {
return GMPNoErr;
}
if (!mHost) {
return GMPGenericErr;
}
ipc::Shmem new_mem;
if (!mHost->SharedMemMgr()->MgrAllocShmem(GMPSharedMemManager::kGMPFrameData, aNewSize,
ipc::SharedMemory::TYPE_BASIC, &new_mem) ||
!new_mem.get<uint8_t>()) {
return GMPAllocErr;
}
if (mBuffer.IsReadable()) {
memcpy(new_mem.get<uint8_t>(), Buffer(), mSize);
}
DestroyBuffer();
mBuffer = new_mem;
return GMPNoErr;
}
CTerrainMgr::~CTerrainMgr()
{
DestroyBuffer();
SafeRelease(m_Texture);
m_pGroup->UnRegisterBatch( ID_TERRAIN_FILTER , this );
g_TerrainTexHandler.UnRegisterTerrainMgr(this);
}
/*************************************
* SetBufferSize
*************************************/
SHVBool SHVBufferPtr::SetBufferSize(size_t newSize, size_t toCopyFromOld)
{
SHVByte* oldBuf = BufferPtr;
size_t copySize = (BufferSize < toCopyFromOld ? BufferSize : toCopyFromOld);
SHVBool retVal(SHVBool::True);
// test if the new buffer is smaller than what we want to copy - then truncate
if (copySize > newSize)
copySize = newSize;
BufferSize = newSize;
if (newSize == 0)
{
BufferPtr = NULL;
}
else
{
BufferPtr = AllocBuffer(newSize);
if (BufferPtr == NULL)
{
BufferPtr = oldBuf;
return SHVBufferC::ErrAlloc;
}
else if (copySize > 0)
{
memcpy(BufferPtr,oldBuf,copySize);
}
}
DestroyBuffer(oldBuf);
return SHVBool::True;
}
void CIOBuffer::Allocator::Release( CIOBuffer *pBuffer )
{
if ( !pBuffer )
{
throw CException( _T("CIOBuffer::Allocator::Release()"), _T("pBuffer is null") );
}
CCriticalSection::Owner lock( m_criticalSection );
OnBufferReleased();
/*
* unlink from the in use list
*/
pBuffer->RemoveFromList();
if ( m_maxFreeBuffers == 0 || m_freeList.Count() < m_maxFreeBuffers )
{
pBuffer->Empty();
/*
* add to the free list
*/
m_freeList.PushNode( pBuffer );
}
else
{
DestroyBuffer( pBuffer );
}
}
void XnBufferPool::FreeAll(XnBool bForceDestroyOfLockedBuffers)
{
XnStatus nRetVal = XN_STATUS_OK;
// free existing buffers
XnBuffersList::Iterator it = m_AllBuffers.begin();
while (it != m_AllBuffers.end())
{
XnBuffersList::Iterator currIt = it;
// first advance (we might remove this item)
++it;
// now check current
XnBufferInPool* pBuffer = *currIt;
// check if item is in free list (or we're forcing deletion)
if (bForceDestroyOfLockedBuffers || pBuffer->m_nRefCount == 0)
{
DestroyBuffer(pBuffer);
m_AllBuffers.Remove(currIt);
}
else
{
// we can't free it, cause it's still locked. instead, mark it for deletion
pBuffer->m_bDestroy = TRUE;
}
}
m_FreeBuffers.Clear();
}
/**
\brief close audio device
\param immed stop playback immediately
*/
static void uninit(struct ao *ao)
{
reset(ao);
DestroyBuffer(ao);
UninitDirectSound(ao);
}
void CIOBuffer::Allocator::Flush()
{
CCriticalSection::Owner lock( m_criticalSection );
while ( !m_activeList.Empty() )
{
OnBufferReleased();
DestroyBuffer( m_activeList.PopNode() );
}
while ( !m_freeList.Empty() )
{
DestroyBuffer( m_freeList.PopNode() );
}
}
void CIOBuffer::Allocator::Flush()
{
CCriticalSection::Owner lock(m_criticalSection);
while (!m_activeList.Empty())
{
//lint -e{1933} call to unqualified virtual function
OnBufferReleased();
DestroyBuffer(m_activeList.PopNode());
}
while (!m_freeList.Empty())
{
DestroyBuffer(m_freeList.PopNode());
}
}
/**
\brief close audio device
\param immed stop playback immediately
*/
static void uninit(struct ao *ao, bool immed)
{
if (!immed)
mp_sleep_us(get_delay(ao) * 1000000);
reset(ao);
DestroyBuffer(ao);
UninitDirectSound(ao);
}
/*****************************************************************************
* Close: close the audio device
*****************************************************************************/
static void Stop ( audio_output_t *p_aout )
{
aout_sys_t *p_sys = p_aout->sys;
kaiClose( p_sys->hkai );
kaiDone();
DestroyBuffer( p_aout );
}
NSCAPI::errorReturn nscapi::core_wrapper::registry_query(const std::string request, std::string &response) const {
char *buffer = NULL;
unsigned int buffer_size = 0;
NSCAPI::errorReturn retC = registry_query(request.c_str(), static_cast<unsigned int>(request.size()), &buffer, &buffer_size);
if (buffer_size > 0 && buffer != NULL) {
response = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
return retC;
}
bool nscapi::core_wrapper::json_to_protobuf(const std::string &request, std::string &response) const {
char *buffer = NULL;
unsigned int buffer_size = 0;
bool retC = NSCAPI::api_ok(json_to_protobuf(request.c_str(), static_cast<unsigned int>(request.size()), &buffer, &buffer_size));
if (buffer_size > 0 && buffer != NULL) {
response = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
return retC;
}
bool nscapi::core_wrapper::protobuf_to_json(const std::string &object, const std::string &request, std::string &response) const {
char *buffer = NULL;
unsigned int buffer_size = 0;
NSCAPI::errorReturn retC = protobuf_to_json(object.c_str(), request.c_str(), static_cast<unsigned int>(request.size()), &buffer, &buffer_size);
if (buffer_size > 0 && buffer != NULL) {
response = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
return retC == NSCAPI::isSuccess;
}
void DestroyScanner(CJcScanner* scanner){
char* cur = (char*) scanner->pFirstHeap;
while(cur != NULL){
cur = *(char**) (cur + HEAP_BLOCK_SIZE);
g_oInterface.Free(scanner->pFirstHeap);
scanner->pFirstHeap = cur;
}
g_oInterface.Free(scanner->tval);
DestroyBuffer(scanner->buffer);
g_oInterface.Free(scanner->buffer);
DestroyKeywordMap(&scanner->keywords);
DestroyStartStates(&scanner->start);
}
NSCAPI::errorReturn nscapi::core_wrapper::submit_message(std::string channel, std::string request, std::string &response) {
if (!fNSAPINotify)
throw nscapi::nscapi_exception("NSCore has not been initiated...");
char *buffer = NULL;
unsigned int buffer_size = 0;
NSCAPI::nagiosReturn ret = submit_message(channel.c_str(), request.c_str(), static_cast<unsigned int>(request.size()), &buffer, &buffer_size);
if (buffer_size > 0 && buffer != NULL) {
response = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
return ret;
}
/**
* Resizes the buffer to the passed in number of indices.
* Preserves internal data
*/
void FSlateOpenGLIndexBuffer::ResizeBuffer( uint32 NumIndices )
{
// Only resize if the index buffer cant provide the number of indices requested
if( NumIndices > MaxNumIndices )
{
// Determine the current buffer size so we can save off the current indices
uint32 CurrentBufferSize = MaxNumIndices*sizeof(SlateIndex);
uint8 *SavedIndices = NULL;
// If there are any indices at all save them off now
if( MaxNumIndices > 0 )
{
void *Indices = Lock( 0 );
SavedIndices = new uint8[CurrentBufferSize];
FMemory::Memcpy( SavedIndices, Indices, CurrentBufferSize );
Unlock();
// Destroy the current buffer. It needs to be recreated with a larger size
DestroyBuffer();
}
// Calculate the new buffer size
BufferSize = NumIndices*sizeof(SlateIndex);
// Create the index buffer
ConditionalCreateBuffer();
// Bind the buffer so we can give it data
Bind();
MaxNumIndices = NumIndices;
// Set the index buffer's size
glBufferData( GL_ELEMENT_ARRAY_BUFFER, BufferSize, NULL, GL_DYNAMIC_DRAW );
// If there are any saved indices, copy them back now.
if( SavedIndices )
{
void *Indices = Lock( 0 );
FMemory::Memcpy( Indices, SavedIndices, CurrentBufferSize );
Unlock();
delete[] SavedIndices;
}
}
}
bool nscapi::core_wrapper::exec_command(const std::string target, std::string request, std::string & result) const {
char *buffer = NULL;
unsigned int buffer_size = 0;
bool retC = NSCAPI::api_ok(exec_command(target.c_str(), request.c_str(), static_cast<unsigned int>(request.size()), &buffer, &buffer_size));
if (buffer_size > 0 && buffer != NULL) {
result = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
if (!retC) {
CORE_LOG_ERROR("Failed to execute command on " + target);
}
return retC;
}
NSCAPI::nagiosReturn nscapi::core_wrapper::exec_command(const std::string target, std::string request, std::string & result) {
char *buffer = NULL;
unsigned int buffer_size = 0;
NSCAPI::nagiosReturn retC = exec_command(target.c_str(), request.c_str(), static_cast<unsigned int>(request.size()), &buffer, &buffer_size);
if (buffer_size > 0 && buffer != NULL) {
result = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
if (retC != NSCAPI::isSuccess) {
CORE_LOG_ERROR("Failed to execute command on " + target + ": " + strEx::s::xtos(retC));
}
return retC;
}
void CCamera::Destroy (void)
{
m_info.buffer.ReleaseTexture ();
ogl.DeleteTextures (1, &m_info.glTexId);
if (m_info.screenBuf && (m_info.screenBuf != m_info.buffer.Buffer ())) {
delete m_info.screenBuf;
m_info.screenBuf = NULL;
}
if (m_info.buffer.Buffer ()) {
m_info.buffer.DestroyBuffer ();
}
#if RENDER2TEXTURE
if (ogl.m_states.bRender2TextureOk)
DestroyBuffer ();
#endif
}
/**
* Resizes the buffer to the passed in number of indices.
* Preserves internal data
*/
void FSlateOpenGLVertexBuffer::ResizeBuffer( uint32 NewSize )
{
ConditionalCreateBuffer();
// Only resize if the buffer cant provide the number of bytes requestd
if( NewSize > BufferSize )
{
uint8 *SavedVertices = NULL;
// If there are any indices at all save them off now
if( BufferSize > 0 )
{
void *Vertices = Lock( 0 );
SavedVertices = new uint8[BufferSize];
FMemory::Memcpy( SavedVertices, Vertices, BufferSize );
Unlock();
DestroyBuffer();
}
// Create the vertex buffer
ConditionalCreateBuffer();
// Bind the buffer so we can give it data
Bind();
// Set the vertex buffer's size
glBufferData( GL_ARRAY_BUFFER, NewSize, NULL, GL_DYNAMIC_DRAW );
// If there are any saved vertices, copy them back now.
if( SavedVertices )
{
void *Vertices = Lock( 0 );
FMemory::Memcpy( Vertices, SavedVertices, BufferSize );
Unlock();
delete[] SavedVertices;
}
BufferSize = NewSize;
}
}
ISoundSource* CSoundManager::CreateSource(const wchar *filename, Vec3 position, bool relativeToListener)
{
CSoundBuffer* buff = CreateBuffer(filename);
if(!buff) return NULL;
CSoundSource* source = new CSoundSource();
if(!source)
{
DestroyBuffer(buff);
return NULL;
}
source->Create(m_extensions, buff, position, relativeToListener);
m_sources.push_back(source);
return source;
}
NSCAPI::nagiosReturn nscapi::core_wrapper::query(const std::string & request, std::string & result) const {
if (!fNSAPIInject)
throw nscapi::nscapi_exception("NSCore has not been initiated...");
char *buffer = NULL;
unsigned int buffer_size = 0;
NSCAPI::nagiosReturn retC = query(request.c_str(), static_cast<unsigned int>(request.size()), &buffer, &buffer_size);
if (buffer_size > 0 && buffer != NULL) {
//PluginCommand::ResponseMessage rsp_msg;
result = std::string(buffer, buffer_size);
}
DestroyBuffer(&buffer);
if (retC != NSCAPI::isSuccess) {
CORE_LOG_ERROR("Failed to execute command");
}
return retC;
}
void CSoundManager::DestroySource(ISoundSource *source)
{
if(!source) return;
CSoundBuffer* buff = ((CSoundSource*)source)->GetBuffer();
int size = m_sources.size();
for(int i = 0; i < size; i++)
{
if(m_sources[i] == source)
{
m_sources.erase(m_sources.begin() + i);
break;
}
}
delete source;
DestroyBuffer(buff);
}
