int scan_device()
{
ocl_device_init();
static char vendor_name[STRING_RETURN_SIZE];
status = clGetDeviceInfo (device, CL_DEVICE_VENDOR, STRING_RETURN_SIZE, vendor_name, NULL);
if(status != CL_SUCCESS) dump_error("Failed clGetDeviceInfo(CL_DEVICE_VENDOR)", status);
printf ("Board vendor name: %s\n", vendor_name);
// get all supported board names from MMD
static char board_name[STRING_RETURN_SIZE];
status = clGetDeviceInfo (device, CL_DEVICE_NAME, STRING_RETURN_SIZE, board_name, NULL);
if(status != CL_SUCCESS) dump_error("Failed clGetDeviceInfo(CL_DEVICE_NAME)", status);
printf ("Board name: %s\n\n", board_name);
char *shared_buf1 = (char*)malloc(SHARED_BUFFER_SIZE * sizeof(char));
char *shared_buf2 = (char*)malloc(SHARED_BUFFER_SIZE * sizeof(char));
if (shared_buf1 == NULL || shared_buf2 == NULL) {
dump_error("Failed to allocate two buffers with malloc", 0);
}
int i;
for (i = 0; i < SHARED_BUFFER_SIZE; i++) {
shared_buf1[i] = i;
shared_buf2[i] = -1;
}
cl_mem in1 = clCreateBuffer (context, CL_MEM_READ_WRITE, SHARED_BUFFER_SIZE, NULL, &status);
if(status != CL_SUCCESS) dump_error("Failed clCreateBuffer for in1", status);
status = clEnqueueWriteBuffer (queue, in1, CL_TRUE, 0, SHARED_BUFFER_SIZE, shared_buf1, 0, NULL, NULL);
if (status != CL_SUCCESS) dump_error("Could not launch clEnqueueWriteBuffer!", status);
status = clEnqueueReadBuffer (queue, in1, CL_TRUE, 0, SHARED_BUFFER_SIZE, shared_buf2, 0, NULL, NULL);
if (status != CL_SUCCESS) dump_error("Could not launch clEnqueueWriteBuffer!", status);
for (i = 0; i < SHARED_BUFFER_SIZE; i++) {
if (shared_buf1[i] != shared_buf2[i] ) {
printf("\nBuffer comparison failed!\n");
printf ("#%d: %d vs %d\n", i, shared_buf1[i], shared_buf2[i]);
freeResources();
return -1;
}
}
printf ("Buffer read/write test passed.\n");
free (shared_buf1);
free (shared_buf2);
clReleaseMemObject (in1);
freeResources();
return 0;
}
void TrainTask::returnUnit(Unit unit)
{
if(mProductionBuilding == unit)
{
freeResources();
mProductionBuilding = StaticUnits::nullunit;
}
else if(mProducedUnit == unit)
{
freeResources();
mProducedUnit = StaticUnits::nullunit;
}
else
assert(false);
}
/*
* ======== freeAlgResources ========
*/
static Bool freeAlgResources(BUFALG_TI_Handle alg, IRES_Fxns *fxns,
Int scratchId)
{
IRES_ResourceDescriptor desc[MAXDESCS];
IALG_Handle h = (IALG_Handle)alg;
Int numRes;
Int status;
numRes = (fxns->numResourceDescriptors)(h);
if (numRes > MAXDESCS) {
System_printf("Too many resources: %d\n", numRes);
return (FALSE);
}
System_printf("Number of resources: %d\n", numRes);
status = (fxns->getResourceDescriptors)(h, desc);
if (status != IRES_OK) {
System_printf("Failed to get resource descriptors\n");
return (FALSE);
}
freeResources(h, desc, numRes, scratchId);
return (TRUE);
}
DesktopWindowLinux::DesktopWindowLinux(DesktopWindowClient* client, int width, int height)
: DesktopWindow(client, width, height)
, m_eventSource(0)
, m_display(0)
, m_window(0)
, m_im(0)
, m_ic(0)
, m_cursor(0)
, m_currentX11Cursor(XC_left_ptr)
, m_lastClickTime(0)
, m_lastClickX(0)
, m_lastClickY(0)
, m_lastClickButton(kWKEventMouseButtonNoButton)
, m_clickCount(0)
{
try {
setup();
} catch(const FatalError&) {
freeResources();
throw;
}
m_eventSource = new XlibEventSource(m_display, this);
makeCurrent();
glEnable(GL_DEPTH_TEST);
}
MediaImpl::~MediaImpl()
{
freeResources();
/* _data points to gstreamer-allocated data, we don't manage it ourselves */
//if (_data)
// free(_data);
}
Xsltproc::ReturnValue Xsltproc::execute()
{
Xsltproc::ReturnValue retval = Xsltproc::Success;
try
{
if( freopen(mErrorFilename.toUtf8().data(),"w",stderr) == NULL ) throw Xsltproc::GenericFailure;
mStylesheet = xsltParseStylesheetFile( (const xmlChar*)mStyleSheetFilename.toUtf8().data() );
if(mStylesheet == 0) throw Xsltproc::InvalidStylesheet;
mXml = xmlParseFile( (const char*)mXmlFilename.toUtf8().data() );
if(mXml == 0) throw Xsltproc::InvalidXmlFile;
mOutput = xsltApplyStylesheet(mStylesheet, mXml, (const char**)mParams);
if(mOutput == 0) throw Xsltproc::GenericFailure;
FILE *foutput = 0;
foutput = fopen(mOutputFilename.toUtf8().data(),"w");
if( foutput == 0 ) throw Xsltproc::CouldNotOpenOutput;
xsltSaveResultToFile(foutput, mOutput, mStylesheet);
fclose(foutput);
}
catch(Xsltproc::ReturnValue e)
{
retval = e;
}
fclose(stderr);
freeResources();
return retval;
}
void TreeBuilder::initialiseParse(const StringRef& input, const StringRef& baseUri, ParseErrorList* errors, Allocator* allocator) {
freeResources();
CSOUP_ASSERT(input.size() > 0 && input.data() != NULL);
CSOUP_ASSERT(baseUri.size() > 0 && baseUri.data() != NULL);
// Don't destroy this
errors_ = errors;
if (allocator == NULL) {
// if invoked didn't give an allocator, you should pass NULL to Document's construtor
// and update allocator.
// User can destroy the document using delete expression. And this should be the usual case.
doc_ = new Document(baseUri, allocator);
allocator = doc_->allocator();
} else {
// when user specify the allocator, you should initialize memory for Document from it.
// User must invoke free of allocator in order to destroy Document.
// User shouldn't use this style except the some extreme cases.
doc_ = new (allocator->malloc_t<Document>()) Document(baseUri, allocator);
}
reader_ = new (allocator->malloc_t<CharacterReader>()) CharacterReader(input);
tokeniser_ = new (allocator->malloc_t<Tokeniser>()) Tokeniser(reader_, errors, allocator);
stack_ = new (allocator->malloc_t< internal::Vector<Element*> >()) internal::Vector<Element*>(4, allocator);
baseUri_ = new (allocator->malloc_t< String>()) String(baseUri, allocator);
allocator_ = allocator;
currentToken_ = NULL;
}
ExVPJoinTcb::~ExVPJoinTcb()
{
delete qParent_.up;
delete qParent_.down;
freeResources();
}
ExIarTcb::~ExIarTcb()
{
delete qparent_.up;
delete qparent_.down;
freeResources();
};
ExFastExtractTcb::~ExFastExtractTcb()
{
// Release resources acquired
//
freeResources();
delete qParent_.up;
delete qParent_.down;
if (workAtp_)
{
workAtp_->release();
deallocateAtp(workAtp_, getSpace());
}
if (inSqlBuffer_ && getHeap())
{
getHeap()->deallocateMemory(inSqlBuffer_);
inSqlBuffer_ = NULL;
childOutputTD_ = NULL;
}
if (sourceFieldsConvIndex_)
getHeap()->deallocateMemory(sourceFieldsConvIndex_);
} // ExFastExtractTcb::~ExFastExtractTcb()
ExExeUtilTcb::~ExExeUtilTcb()
{
delete qparent_.up;
delete qparent_.down;
if (workAtp_)
{
workAtp_->release();
deallocateAtp(workAtp_, getGlobals()->getSpace());
workAtp_ = NULL;
}
freeResources();
if (extractedPartsObj_)
{
delete extractedPartsObj_;
extractedPartsObj_ = NULL;
}
if (explQuery_)
NADELETEBASIC(explQuery_, getHeap());
if (childQueryId_ != NULL)
{
NADELETEBASIC(childQueryId_, getHeap());
childQueryId_ = NULL;
childQueryIdLen_ = 0;
}
if (outputBuf_ != NULL)
{
NADELETEBASIC(outputBuf_, getHeap());
outputBuf_ = NULL;
outputBuf_ = 0;
}
};
void ConstructionTask::giveUnit(Unit unit)
{
if(unit->getType() == mType.whatBuilds().first)
{
LOGMESSAGE(String_Builder() << "ConstructionTask : " << mType.getName() << " : Given Builder");
assert(!mBuilder);
mBuilder = unit;
reserveResources();
}
else if(unit == mReservedLocation->getUnitPrediction() || unit->getTilePosition() == mReservedLocation->getTilePosition())
{
LOGMESSAGE(String_Builder() << "ConstructionTask : " << mType.getName() << " : Given Produced Unit");
assert(!mProducedUnit || !mProducedUnit->exists());
mProducedUnit = unit;
if(mProducedUnit->exists())
{
freeResources();
freeLocation();
}
}
else
assert(false);
}
void ConstructionTask::returnUnit(Unit unit)
{
if(unit == mBuilder)
{
LOGMESSAGE(String_Builder() << "ConstructionTask : " << mType.getName() << " : Returning Builder");
freeResources();
mBuilder = StaticUnits::nullunit;
}
else if(unit == mProducedUnit)
{
LOGMESSAGE(String_Builder() << "ConstructionTask : " << mType.getName() << " : Returning Produced Unit");
freeResources();
mProducedUnit = StaticUnits::nullunit;
}
else
assert(!unit->exists());//If it doesn't exist it was a prediction that has been replaced
}
X11Grabber::~X11Grabber()
{
if (_x11Display != nullptr)
{
freeResources();
XCloseDisplay(_x11Display);
}
}
MediaImpl::~MediaImpl()
{
// Free all resources.
freeResources();
// Free mutex locker object.
delete _mutexLocker;
}
int main( int argc, char** argv )
{
srand (time(NULL));
init_platform();
run();
freeResources();
return 0;
}
SharedMemoryBlock::~SharedMemoryBlock() {
// Destructor sin lanzamiento de excepciones
try {
freeResources();
}
catch(const SharedMemoryException &e) {
}
}
void GL3LightingManager::resizeFramebuffer(uint32_t width, uint32_t height) {
// First check if the new size is actually bigger than the old
if (width <= _framebufferSize.x && height <= _framebufferSize.y) {
return; // Framebuffer is big enough, no need to change the size
}
freeResources();
createFrameBuffer(width, height);
}
void ParticleSystem::slotSetParticleRadius(float radius)
{
qDebug() << "ParticleSystem::slotSetParticleRadius(): setting particle radius from" << mParametersSimulation->particleRadius << "to" << radius;
mParametersSimulation->particleRadius = radius;
// Need to rebuild data-structures when particle radius or -count changes.
if(mIsInitialized) freeResources();
//slotInitialize(); will happen lazily on update
}
Shader::Shader(const std::string& vertShader, const std::string& fragShader)
{
auto vertSrc = getShaderSource(vertShader);
auto fragSrc = getShaderSource(fragShader);
createVertexShader(vertSrc);
createFragmentShader(fragSrc);
createProgram();
freeResources();
}
int X11Grabber::updateScreenDimensions()
{
const Status status = XGetWindowAttributes(_x11Display, _window, &_windowAttr);
if (status == 0)
{
Error(_log, "Failed to obtain window attributes");
return -1;
}
if (_screenWidth == unsigned(_windowAttr.width) && _screenHeight == unsigned(_windowAttr.height))
{
// No update required
return 0;
}
if (_screenWidth || _screenHeight)
{
freeResources();
}
Info(_log, "Update of screen resolution: [%dx%d] to [%dx%d]", _screenWidth, _screenHeight, _windowAttr.width, _windowAttr.height);
_screenWidth = _windowAttr.width;
_screenHeight = _windowAttr.height;
// Image scaling is performed by XRender when available, otherwise by ImageResampler
if (_XRenderAvailable && !_useXGetImage)
{
_croppedWidth = (_screenWidth > unsigned(_cropLeft + _cropRight))
? ((_screenWidth - _cropLeft - _cropRight) / _horizontalDecimation)
: _screenWidth / _horizontalDecimation;
_croppedHeight = (_screenHeight > unsigned(_cropTop + _cropBottom))
? ((_screenHeight - _cropTop - _cropBottom) / _verticalDecimation)
: _screenHeight / _verticalDecimation;
Info(_log, "Using XRender for grabbing");
}
else
{
_croppedWidth = (_screenWidth > unsigned(_cropLeft + _cropRight))
? (_screenWidth - _cropLeft - _cropRight)
: _screenWidth;
_croppedHeight = (_screenHeight > unsigned(_cropTop + _cropBottom))
? (_screenHeight - _cropTop - _cropBottom)
: _screenHeight;
Info(_log, "Using XGetImage for grabbing");
}
_image.resize(_croppedWidth, _croppedHeight);
setupResources();
return 1;
}
void UVAnimParticleQuadSystem::setTextureWithRectForAnimation(Texture2D *texture, const Rect& rect,
int tileWidth, int tileHeight, int number_Frames_per_Second, bool NeedsToRemoveParticleAfterAniamtion) {
m_nItemWidth = tileWidth;
m_nItemHeight = tileHeight;
m_bNeedsToRemoveParticleAfterAniamtion = NeedsToRemoveParticleAfterAniamtion;
if (texture && tileWidth > 0 && tileHeight > 0 && number_Frames_per_Second > 0) {
const Size& s = texture->getContentSizeInPixels();
m_nItemsPerColumn = (int)(s.height / m_nItemHeight);
m_nItemsPerRow = (int)(s.width / m_nItemWidth);
m_nFrameCount = m_nItemsPerRow * m_nItemsPerColumn;
m_fFrameRate = 1.f / number_Frames_per_Second;
const float inv_wide = 1.f/texture->getPixelsWide();
const float inv_high = 1.f/texture->getPixelsHigh();
freeResources();
const int UVCount = (m_nItemsPerColumn+1) * (m_nItemsPerRow+1);
m_pTexCoords = new Tex2F[UVCount];
Tex2F *texPtr = m_pTexCoords;
// Important. Texture in cocos2d are inverted, so the Y component should be inverted
for (int j = 0; j <= m_nItemsPerColumn; ++j) {
const float y = (rect.origin.y + m_nItemHeight*j)*inv_high;
for (int i = 0; i <= m_nItemsPerRow; ++i) {
texPtr->u = (rect.origin.x + m_nItemWidth*i)*inv_wide;
texPtr->v = y;
++texPtr;
}
}
m_pUVRects = new UVRect[m_nFrameCount];
UVRect *rectPtr = m_pUVRects;
for (int j = 0; j < m_nItemsPerColumn; ++j) {
Tex2F *texPtr = m_pTexCoords + j * (m_nItemsPerRow+1);
for (int i = 0; i < m_nItemsPerRow; ++i) {
Tex2F *ptr = texPtr + i;
rectPtr->tl = ptr;
rectPtr->tr = ptr + 1;
rectPtr->bl = ptr + m_nItemsPerRow + 1;
rectPtr->br = ptr + m_nItemsPerRow + 2;
//CCLOG("%f,%f;%f,%f;%f,%f;%f,%f;", \
rectPtr->tl->u,rectPtr->tl->v, \
rectPtr->tr->u,rectPtr->tr->v, \
rectPtr->bl->u,rectPtr->bl->v, \
rectPtr->br->u,rectPtr->br->v);
++rectPtr;
}
}
ParticleSystemQuad::setTextureWithRect(texture, Rect(rect.origin.x, rect.origin.y, tileWidth, tileHeight));
} else {
void Text::regenerate()
{
if (!doc)
{
doc = DocumentCache::getInstance().pop();
dirty = true;
}
if (dirty)
{
doc->setDefaultFont(defFont);
if (elide)
{
QFontMetrics metrics = QFontMetrics(defFont);
QString elidedText = metrics.elidedText(text, Qt::ElideRight, qRound(width));
doc->setPlainText(elidedText);
}
else
{
doc->setDefaultStyleSheet(defStyleSheet);
doc->setHtml(text);
}
// wrap mode
QTextOption opt;
opt.setWrapMode(elide ? QTextOption::NoWrap : QTextOption::WrapAtWordBoundaryOrAnywhere);
doc->setDefaultTextOption(opt);
// width
doc->setTextWidth(width);
doc->documentLayout()->update();
// update ascent
if (doc->firstBlock().layout()->lineCount() > 0)
ascent = doc->firstBlock().layout()->lineAt(0).ascent();
// let the scene know about our change in size
if (size != idealSize())
prepareGeometryChange();
// get the new width and height
size = idealSize();
dirty = false;
}
// if we are not visible -> free mem
if (!keepInMemory)
freeResources();
}
StaticMapLayer::StaticMapLayer(const QVector<QVector<StaticMapObject*>> & staticObjects) :
staticObjects(staticObjects)
{
try
{
checkArguments(staticObjects);
}
catch(...)
{
freeResources();
throw;
}
}
void MediaImpl::unloadMovie()
{
// Reset variables.
_terminate = false;
_seekEnabled = false;
// Un-ready.
_setMovieReady(false);
setPlayState(false);
// Free allocated resources.
freeResources();
}
// Destructor
//
//
ExSequenceTcb::~ExSequenceTcb()
{
if(qparent_.up) delete qparent_.up;
qparent_.up = NULL;
if(qparent_.down) delete qparent_.down;
qparent_.down = NULL;
if(pool_) delete pool_;
pool_ = NULL;
freeResources();
}
bool ConstructionTask::preUpdate()
{
if(mProducedUnit)
{
if(mProducedUnit->exists())
{
freeResources();
freeLocation();
}
if(!isStopped() && !isCanceled() && mProducedUnit->isCompleted())
{
complete();
return true;
}
}
if(mReservedLocation)
{
if(hasEnded())
freeLocation();
else if(isPaused() || isStopped())
{
freeResources();
mRequiredSatisfyTime = Requirement::maxTime;
mRequiredDelayTime = Requirement::maxTime;
mReservedLocation->setStartTime(Requirement::maxTime);
}
}
if(!shouldReturnUnit())
updateRequirements();
if(mBuilder && finishedWithBuilder() && (mType.getRace() == BWAPI::Races::Protoss || !mBuilder->isConstructing()))
return true;
return false;
}
void TrainTask::giveUnit(Unit unit)
{
if(unit->getType() == mType.whatBuilds().first)
{
reserveResources();
mProductionBuilding = unit;
}
else
{
freeResources();
mProducedUnit = unit;
}
}
//------------------------------------------------------------------------------------------------
// Name: stateConnect
// Desc:
//------------------------------------------------------------------------------------------------
void VolucrisClient::stateLostD3DDevice()
{
// Get rid of everything
global_actor_manager_.onLostDevice();
global_rendering_manager_.resetCurrentTexture();
freeResources();
mySceneryRenderer.destroy();
global_map_manager_.clearCache();
global_sound_manager_.destroy();
// Wait for a connection reply from the server
HRESULT hr;
while(D3DERR_DEVICELOST == (hr = myD3DDevice->TestCooperativeLevel()))
{
if (!windowsMessagePump())
{
myStateMachine.jumpState(VCS_SHUTDOWN);
return;
}
// Poll the connection to keep it alive. Watch for disconnection.
ENetEvent netEvent;
while(enet_host_service(myENetClient, &netEvent, 0) > 0) {
if (netEvent.type == ENET_EVENT_TYPE_DISCONNECT) {
myStateMachine.jumpState(VCS_SHUTDOWN);
return;
}
// Free packet memory
if (netEvent.packet) enet_packet_destroy(netEvent.packet);
}
// Don't overload the program
Sleep(200);
}
CONFIRM(hr == D3DERR_DEVICENOTRESET && SUCCEEDED(myD3DDevice->Reset(&myD3DParams))) else {
myStateMachine.jumpState(VCS_SHUTDOWN);
return;
}
// Reset everything
if (APP_FATAL(!acquireResources())("The game couldn't load its resource file")) {
myStateMachine.jumpState(VCS_DISCONNECT);
myStateMachine.jumpState(VCS_SHUTDOWN);
return;
}
mySceneryRenderer.create(myD3DDevice, myUsingSoftwareDeviceFlag);
global_sound_manager_.create(myMainWindow);
}
bool ConstructionTask::morph(Unit unit, BWAPI::UnitType previousType)
{
if(unit == mBuilder && unit->getType() == mType)
{
freeLocation();
freeResources();
mProducedUnit = unit;
mBuilder = StaticUnits::nullunit;
return false;
}
return true;
}
