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