moDMatrix<Real>& moDMatrix<Real>::operator= (const moDMatrix& rkM)
{
if (rkM.m_iQuantity > 0)
{
if (m_iRows != rkM.m_iRows || m_iCols != rkM.m_iCols)
{
Deallocate();
m_iRows = rkM.m_iRows;
m_iCols = rkM.m_iCols;
m_iQuantity = rkM.m_iQuantity;
Allocate(false);
}
for (int iRow = 0; iRow < m_iRows; iRow++)
{
for (int iCol = 0; iCol < m_iCols; iCol++)
{
m_aafEntry[iRow][iCol] = rkM.m_aafEntry[iRow][iCol];
}
}
}
else
{
Deallocate();
m_iRows = 0;
m_iCols = 0;
m_iQuantity = 0;
m_afData = 0;
m_aafEntry = 0;
}
return *this;
}
EditorFrame::~EditorFrame()
{
#ifdef EDITOR_OLD_UI
Deallocate(documentManager);
eventManager->disconnectPluginListeners();
#endif
ArchiveDestroy(archive);
pluginManager->disablePlugins();
Deallocate(pluginManager);
Deallocate(eventManager);
Deallocate(input);
#ifdef EDITOR_OLD_UI
if(notebookCtrl)
{
notebookCtrl->Destroy();
paneCtrl->DetachPane(notebookCtrl);
}
if(paneCtrl)
{
paneCtrl->UnInit();
delete paneCtrl;
}
#endif
Deallocate(engine);
CoreDeinitialize();
}
Resource* OGG_Loader::prepare(ResourceLoadOptions& options)
{
ResourceLoadOption& option = options.option;
bool streamed = option.key == SOUND_LOAD_STREAM && option.value;
Sound* sound = AllocateThis(Sound);
if( !streamed) return sound;
sound->setStreamed(true);
options.keepStreamOpen = true;
options.resource = sound;
OggVorbis_File* oggFile = AllocateThis(OggVorbis_File);
if( !initOgg(oggFile, options) )
{
Deallocate(oggFile);
Deallocate(sound);
return nullptr;
}
OggStream* oggStream = AllocateThis(OggStream);
oggStream->loader = this;
oggStream->stream = options.stream;
oggStream->ogg = oggFile;
oggStream->begin = oggStream->ogg->offset;
sound->stream = oggStream;
return sound;
}
BSplineBasis<Real>::~BSplineBasis ()
{
delete1(mKnot);
Deallocate(mBD0);
Deallocate(mBD1);
Deallocate(mBD2);
Deallocate(mBD3);
}
ResourceManager::~ResourceManager()
{
destroyHandles();
resourceLoaders.clear();
Deallocate(resourceFinishLoad);
Deallocate(resourceFinishLoadMutex);
}
void DestroyLineSet( PLINESEGSET pls )
{
if( pls )
{
if( pls->pLines )
Deallocate( PLINESEG, pls->pLines );
Deallocate( PLINESEGSET pls );
}
}
Adventure::ITexture* Adventure::Image::LoadTgaFromFile(File& file, IDisplay& display, Allocator* scratch)
{
file.GetStream().seekg(2, std::ios::beg);
File::UInt8 type;
file.Read(type);
if (type != 2) // Type 2 indicates a regular image
return NULL;
file.GetStream().seekg(12, std::ios::beg);
File::UInt16 width, height;
file.Read(width);
file.Read(height);
int pixels = width * height;
file.GetStream().seekg(16, std::ios::beg);
File::UInt8 bits;
file.Read(bits);
if (bits < 24)
return NULL;
file.GetStream().seekg(18, std::ios::beg);
Color* pixelData = new(scratch) Color[pixels];
for (int i = 0; i < pixels; i++)
{
// BGRA format
file.Read(pixelData[i].Blue);
file.Read(pixelData[i].Green);
file.Read(pixelData[i].Red);
if (bits == 32)
file.Read(pixelData[i].Alpha);
else
pixelData[i].Alpha = Color::MaxChannelValue;
}
ITexture* texture = display.CreateTexture();
if (texture == NULL)
{
Deallocate(pixelData, scratch);
return NULL;
}
texture->SetData(pixelData, width, height, ITexture::Rgba8, ITexture::Point);
Deallocate(pixelData, scratch);
return texture;
}
Body::~Body()
{
Transform* transform = getEntity()->getTransform().get();
if(transform)
transform->onTransformed.Disconnect( this, &Body::onTransformed );
removeWorld();
Deallocate(motionState);
Deallocate(body);
}
static LOGICAL SetP( TEXTSTR *p, const XML_Char **atts )
{
if( p[0] )
Deallocate( TEXTSTR, p[0] );
if( p[1] )
Deallocate( TEXTSTR, p[1] );
if( atts[0] )
{
p[0] = DupCStr( atts[0] );
p[1] = DupCStr( atts[1] );
return TRUE;
}
else
return FALSE;
}
template <class T> void Vector<T>::CopyToSelf(Vector const & source)
{
UInt length;
ConstElement *it, *source_it, *source_end;
Deallocate();
_ctorMode = source._ctorMode;
if(!source.IsEmpty())
{
length = source.Length();
Allocate(length);
it = _origin;
source_it = source.Begin();
source_end = source.End();
if(_ctorMode != CtorModeEnum::Always)
{
Memory::Move((VoidPtr)source_it, (VoidPtr)it, sizeof(Element) * length);
_last += length;
}
else
while(source_it != source_end)
{
Construct(it++, source_it++);
++_last;
}
}
}
void
MediaEngineWebRTCVideoSource::Shutdown()
{
LOG((__FUNCTION__));
if (!mInitDone) {
return;
}
#ifdef MOZ_B2G_CAMERA
ReentrantMonitorAutoEnter sync(mCallbackMonitor);
#endif
if (mState == kStarted) {
while (!mSources.IsEmpty()) {
Stop(mSources[0], kVideoTrack); // XXX change to support multiple tracks
}
MOZ_ASSERT(mState == kStopped);
}
if (mState == kAllocated || mState == kStopped) {
Deallocate();
}
#ifndef MOZ_B2G_CAMERA
mViECapture->Release();
mViERender->Release();
mViEBase->Release();
#endif
mState = kReleased;
mInitDone = false;
}
void EpsilonVor::ReadIt(std::ifstream & fin){
Matrix co0,oc0;
fin.read((char *) &nnx, sizeof nnx);
fin.read((char *) &nny, sizeof nny);
fin.read((char *) &nnz, sizeof nnz);
fin.read((char *) &co0, sizeof co0);
fin.read((char *) &oc0, sizeof oc0);
fin.read((char *) &nresid, sizeof nresid);
Deallocate();
is_xRefset=true;
is_COset=true;
setMetric(co0);
Allocate();
int ntoken;
fin.read((char *) &ntoken, sizeof ntoken);
char * css=new char [ntoken];
fin.read(css, (sizeof css[0])*ntoken);
string token(css);
ResLabel.clear();
boost::split(ResLabel,token, boost::is_any_of("\t "));
fin.read((char *) &TotalCount, sizeof TotalCount);
fin.read((char *) &M_avg[0], (sizeof M_avg[0])*DIM);
fin.read((char *) &VoroVol[0], (sizeof VoroVol[0])*nresid);
fin.read((char *) &D[0][0][0], (sizeof D[0][0][0])*DIM*DIM*nresid);
fin.read((char *) &G[0][0][0], (sizeof G[0][0][0])*DIM*DIM*nresid);
fin.read((char *) &M[0][0], (sizeof M[0][0])*DIM*nresid);
fin.read((char *) &E[0][0], (sizeof E[0][0])*DIM*nresid);
}
void Path :: Deallocate (Entry * good){
if (good != NULL){
Deallocate (good -> next);
delete good;
}
}
void DoublyLinkedListPriorityQueue:: Deallocate (Entry * & list){
if (list != NULL){
Deallocate (list -> next);
delete list;
}
}
void SelectionPlugin::onMouseButtonRelease( const MouseButtonEvent& event )
{
if( event.button != MouseButton::Left )
return;
SceneDocument* sceneDocument = (SceneDocument*) editor->getDocument();
sceneDocument->getRenderWindow()->setCursorCapture(false);
editor->getDocument()->getWindow()->flagRedraw();
SelectionOperation* selection = nullptr;
if(selections->dragRectangle)
selection = processDragSelection(event);
else
selection = processSelection(event);
if( !selection ) return;
const SelectionCollection& selected = selections->getSelections();
// Prevent duplication of selection events.
if( selected.isSame(selection->selections) )
{
LogDebug("Ignoring duplicated selection");
Deallocate(selection);
return;
}
selection->redo();
UndoManager* undoManager = sceneDocument->getUndoManager();
undoManager->registerOperation(selection);
}
void TileGrid2D::Resize(Vector2i newSize)
{
std::cout<<"\nTileGrid2D::Resize";
Deallocate();
size = newSize;
/// Space in X between the columns, use for creating hexagonal grids, since the distance between each tile should always be 1.0 if possible.
float spaceX = 0;
/// Offset in Y, used for creating hexagonal grids.
Vector2f eachOtherRowOffset;
Vector2f rowSpacing(1,1);
if (gridType == GridType::HEXAGONS)
{
eachOtherRowOffset = Vector2f(0.5f, 0);
rowSpacing = Vector2f(1, 0.86602540378f);
}
for (int y = 0; y < size[1]; ++y)
{
List<Tile*> * list = new List<Tile*>();
for (int x = 0; x < size[0]; ++x)
{
Tile * tile = new Tile();
tile->position = rowSpacing.ElementMultiplication(Vector2f(x,y));
if (y % 2 == 0)
tile->position += eachOtherRowOffset;
list->Add(tile);
}
tiles.Add(list);
}
}
void CARingBuffer::Allocate(int nChannels, UInt32 bytesPerFrame, UInt32 capacityFrames)
{
Deallocate();
//capacityFrames = NextPowerOfTwo(capacityFrames);
mNumberChannels = nChannels;
mBytesPerFrame = bytesPerFrame;
mCapacityFrames = capacityFrames;
//mCapacityFramesMask = capacityFrames - 1;
mCapacityBytes = bytesPerFrame * capacityFrames;
// put everything in one memory allocation, first the pointers, then the deinterleaved channels
UInt32 allocSize = (mCapacityBytes + sizeof(Byte *)) * nChannels;
Byte *p = (Byte *)CA_malloc(allocSize);
memset(p, 0, allocSize);
mBuffers = (Byte **)p;
p += nChannels * sizeof(Byte *);
for (int i = 0; i < nChannels; ++i) {
mBuffers[i] = p;
p += mCapacityBytes;
}
for (UInt32 i = 0; i<kGeneralRingTimeBoundsQueueSize; ++i)
{
mTimeBoundsQueue[i].mStartTime = 0;
mTimeBoundsQueue[i].mEndTime = 0;
mTimeBoundsQueue[i].mUpdateCounter = 0;
}
mTimeBoundsQueuePtr = 0;
}
void moDMatrix<Real>::SetMatrix (int iRows, int iCols, const Real** aafEntry)
{
Deallocate();
if (iRows > 0 && iCols > 0)
{
m_iRows = iRows;
m_iCols = iCols;
m_iQuantity = m_iRows*m_iCols;
Allocate(false);
for (int iRow = 0; iRow < m_iRows; iRow++)
{
for (int iCol = 0; iCol < m_iCols; iCol++)
{
m_aafEntry[iRow][iCol] = aafEntry[iRow][iCol];
}
}
}
else
{
m_iRows = 0;
m_iCols = 0;
m_iQuantity = 0;
m_afData = 0;
m_aafEntry = 0;
}
}
void CTexture::Allocate( int width, int height, int ctype )
{
if ( (m_width == width) && (m_height == height) && (m_type == ctype) )
return;
Deallocate();
TextureGetSize( ctype, &m_compsize, &m_pixelsize, &m_nelements );
if ( m_compsize == 0 || m_pixelsize == 0 || m_nelements == 0) // Sanity check
{
printf ("CTexture::Allocate - Unknown format %08X\n", ctype );
return;
}
m_width = width;
m_height = height;
m_area = width * height;
m_type = ctype;
m_size = m_area * m_pixelsize;
m_pdata = new TEXBYTE[m_size];
m_pitch = m_pixelsize * m_width;
if ( ctype == TEX_PALETTE )
m_pcolormap = new colmap4f[256];
}
void
MediaEngineWebRTCVideoSource::Shutdown()
{
LOG((__FUNCTION__));
if (!mInitDone) {
return;
}
if (mState == kStarted) {
SourceMediaStream *source;
bool empty;
while (1) {
{
MonitorAutoLock lock(mMonitor);
empty = mSources.IsEmpty();
if (empty) {
break;
}
source = mSources[0];
}
Stop(source, kVideoTrack); // XXX change to support multiple tracks
}
MOZ_ASSERT(mState == kStopped);
}
if (mState == kAllocated || mState == kStopped) {
Deallocate();
}
mViECapture = nullptr;
mViERender = nullptr;
mViEBase = nullptr;
mState = kReleased;
mInitDone = false;
}
void FSTCARingBuffer::AllocateWithABL(const AudioBufferList *abl) // Assumes floating-point data
{
Deallocate();
if(abl->mNumberBuffers == 0)
return;
UInt32 idx, byteSize = offsetof(AudioBufferList, mBuffers[0]) + (sizeof(AudioBuffer) * abl->mNumberBuffers);
mBufferList = (AudioBufferList *)malloc(byteSize);
memset(mBufferList, 0, byteSize);
mBufferList->mNumberBuffers = abl->mNumberBuffers;
for(idx=0; idx<mBufferList->mNumberBuffers; idx++)
{
mBufferList->mBuffers[idx].mNumberChannels = abl->mBuffers[idx].mNumberChannels;
mBufferList->mBuffers[idx].mDataByteSize = abl->mBuffers[idx].mDataByteSize;
mBufferList->mBuffers[idx].mData = malloc(mBufferList->mBuffers[idx].mDataByteSize);
}
mCapacityFrames = abl->mBuffers[0].mDataByteSize/abl->mBuffers[0].mNumberChannels/sizeof(float);
for (UInt32 i = 0; i<kFSTGeneralRingTimeBoundsQueueSize; ++i)
{
mTimeBoundsQueue[i].mStartTime = 0;
mTimeBoundsQueue[i].mEndTime = 0;
mTimeBoundsQueue[i].mUpdateCounter = 0;
}
mTimeBoundsQueuePtr = 0;
}
moDBandedMatrix<Real>& moDBandedMatrix<Real>::operator= (const moDBandedMatrix& rkM)
{
Deallocate();
m_iSize = rkM.m_iSize;
m_iLBands = rkM.m_iLBands;
m_iUBands = rkM.m_iUBands;
Allocate();
size_t uiSize = m_iSize*sizeof(Real);
memcpy(m_afDBand,rkM.m_afDBand,uiSize);
int i;
for (i = 0; i < m_iLBands; i++)
{
uiSize = (m_iSize-1-i)*sizeof(Real);
memcpy(m_aafLBand[i],rkM.m_aafLBand[i],uiSize);
}
for (i = 0; i < m_iUBands; i++)
{
uiSize = (m_iSize-1-i)*sizeof(Real);
memcpy(m_aafUBand[i],rkM.m_aafUBand[i],uiSize);
}
return *this;
}
void
MediaEngineGonkVideoSource::Shutdown()
{
LOG((__FUNCTION__));
if (!mInitDone) {
return;
}
ReentrantMonitorAutoEnter sync(mCallbackMonitor);
if (mState == kStarted) {
SourceMediaStream *source;
bool empty;
while (1) {
{
MonitorAutoLock lock(mMonitor);
empty = mSources.IsEmpty();
if (empty) {
break;
}
source = mSources[0];
}
Stop(source, kVideoTrack); // XXX change to support multiple tracks
}
MOZ_ASSERT(mState == kStopped);
}
if (mState == kAllocated || mState == kStopped) {
Deallocate();
}
mState = kReleased;
mInitDone = false;
}
bool tTexture::LoadImage(std::string filename) {
//This function uses the surface to load an image, then create a texture out of it
Deallocate();
//Create a "Guinna Pig" texture
SDL_Texture* thePig = NULL;
//Load a BMP into theSurface. BMP Is the only file type that native SDL2 can import. W(e will have to add SDL2_image to import other formats)
theSurface = SDL_LoadBMP(filename.c_str()); //SDL_LoadBMP expects a ( char[] )
//Debug VV
if(theSurface == NULL) {
std::cout << "Could not Load image! : " << SDL_GetError() <<std::endl;
} else {
//theTexture = SDL_CreateTextureFromSurface(theRenderer, theSurface);
thePig = SDL_CreateTextureFromSurface(theRenderer, theSurface);
//Debug VV
if(thePig == NULL) {
std::cout << "Could not create texture! : " << SDL_GetError() <<std::endl;
}
//Set the height and width. -> ->(Remember that theSurface is a pointer)
tWidth = theSurface->w;
tHeight = theSurface->h;
//We are going to recycle our global "Surface"
SDL_FreeSurface(theSurface);
theSurface = NULL;
}
//Here is where we copy thePig into sTexture: If anything went wrong, thePig would have been NULL
sTexture = thePig;
return sTexture != NULL;
}
void
MediaEngineRemoteVideoSource::Shutdown()
{
LOG((__PRETTY_FUNCTION__));
if (!mInitDone) {
return;
}
if (mState == kStarted) {
SourceMediaStream *source;
bool empty;
while (1) {
{
MonitorAutoLock lock(mMonitor);
empty = mSources.IsEmpty();
if (empty) {
MOZ_ASSERT(mPrincipalHandles.IsEmpty());
break;
}
source = mSources[0];
}
Stop(source, kVideoTrack); // XXX change to support multiple tracks
}
MOZ_ASSERT(mState == kStopped);
}
for (auto& registered : mRegisteredHandles) {
MOZ_ASSERT(mState == kAllocated || mState == kStopped);
Deallocate(registered.get());
}
MOZ_ASSERT(mState == kReleased);
Super::Shutdown();
mInitDone = false;
}
void CMTDHistory::SetCoordinate(unsigned int id,
const CSmallString& name,
const CSmallString& type,
double min_value,double max_value,unsigned int nbins)
{
if( Sizes == NULL ){
RUNTIME_ERROR("Sizes is NULL");
}
if( id < 0 || id >= NCoords ){
INVALID_ARGUMENT("id out-of-range");
}
if( nbins <= 0 ){
INVALID_ARGUMENT("nbins <= 0");
}
if( max_value < min_value ){
INVALID_ARGUMENT("max_value < min_value");
}
if(Buffers.NumOfMembers() > 0) {
// it was already finalized - destroy data
Deallocate();
}
Sizes[id].Type = type;
Sizes[id].Name = name;
Sizes[id].MinValue = min_value;
Sizes[id].MaxValue = max_value;
Sizes[id].NBins = nbins;
Sizes[id].BinWidth = (Sizes[id].MaxValue - Sizes[id].MinValue)/Sizes[id].NBins;
Sizes[id].Width = Sizes[id].MaxValue - Sizes[id].MinValue;
}
void CTexture::Allocate( CTexture &texsrc )
{
if ( (texsrc.m_width == m_width) &&
(texsrc.m_height == m_height) &&
(texsrc.m_type == m_type) )
return;
Deallocate();
TextureGetSize( texsrc.m_type, &m_compsize, &m_pixelsize, &m_nelements );
if ( (m_compsize == 0) || (m_pixelsize == 0) || (m_nelements == 0) )
return;
m_width = texsrc.m_width;
m_height = texsrc.m_height;
m_area = m_width * m_height;
m_type = texsrc.m_type;
m_size = m_area * m_pixelsize;
m_pdata = new TEXBYTE[m_size];
m_pitch = m_pixelsize * m_width;
if ( m_type == TEX_PALETTE )
m_pcolormap = new colmap4f[256];
}
void CMTDHistory::SetPVector(const CSimpleVector<double>& pvector)
{
unsigned int curr_position = 0;
CMTDBuffer* p_buff = NULL;
int loc = 0;
Deallocate();
while(loc < pvector.GetLength()) {
if((p_buff == NULL) || (curr_position >= MaxBufferSize)) {
// allocate new buffer
p_buff = GetNewBuffer(MaxBufferSize);
curr_position = 0;
}
// now set height
p_buff->SetHeight(curr_position,pvector[loc++]);
for(unsigned int i=0; i < GetNumberOfCoords(); i++) {
// set value and width
p_buff->SetValue(curr_position,i,pvector[loc++]);
p_buff->SetWidth(curr_position,i,pvector[loc++]);
}
p_buff->IncNumberOfHills();
curr_position++;
}
}
char *GetKey( void )
{
static char old_path[256];
DWORD dwType;
DWORD data = 0;
HKEY hTemp;
DWORD dwStatus;
DWORD data_size = sizeof( old_path );
TEXTSTR optional_wide;
#ifdef _UNICODE
optional_wide = MyCharWConvert( MyKey );
#else
optional_wide = MyKey;
#endif
dwStatus = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
optional_wide, 0,
KEY_READ, &hTemp );
if( dwStatus == ERROR_SUCCESS )
{
dwStatus = RegQueryValueEx( hTemp,
WIDE("Install_Dir"),
NULL,
&dwType,
(LPBYTE)old_path,
&data_size );
//printf( "Result was %d\n", dwStatus );
}
#ifdef _UNICODE
Deallocate( TEXTSTR, optional_wide );
#endif
//printf( "Result is %s[%s]\n", MyKey, old_path );
return old_path;
}
Vertex Centroid::Run(int width, int height, Vertices vertices) {
int required_bytes = sizeof(float) * width * height;
if (bytes_ < required_bytes) {
bytes_ = required_bytes;
for (int n = 0; n < 4; n++) {
if (buffer_[n] != NULL)
Deallocate((void*)buffer_[n]);
Allocate((void**)&(buffer_[n]), bytes_);
}
}
CentroidKernel(width, height, vertices, buffer_);
// Compute Centroid
Vertex center;
int count;
center.x = Reduce(width * height, buffer_[0]);
center.y = Reduce(width * height, buffer_[1]);
center.z = Reduce(width * height, buffer_[2]);
count = Reduce(width * height, buffer_[3]);
center.x /= count;
center.y /= count;
center.z /= count;
return center;
}
